ArduWiki glcotiwg_wiki https://arduwiki.perut.org/index.php/P%C3%A1gina_principal MediaWiki 1.27.7 case-sensitive Medio Especial Discusión Usuario Usuario discusión ArduWiki ArduWiki discusión Archivo Archivo discusión MediaWiki MediaWiki discusión Plantilla Plantilla discusión Ayuda Ayuda discusión Categoría Categoría discusión 0 253 3737 1029 2019-05-06T22:09:04Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Sensores</categorytree> == Referencias == [[Category:Sensores]] phrz68vyt00mk72xrwh41yn8g07pld8 0 231 3895 3741 2019-05-12T22:01:13Z Kike GL 2 /* Salida */ wikitext text/x-wiki Este ejemplo demuestra las funciones avanzadas de impresión en serie al generar en el monitor serie del Software Arduino (IDE) una tabla de caracteres y sus valores ASCII en decimal, hexadecimal, octal y binario. Para más información sobre ASCII, vea [http://www.asciitable.com%20and%20http//en.wikipedia.org/wiki/ASCII asciitable.com] == Placa aplicable == Todas. == Los caracteres de control == Aquí tenemos una lista de los caracteres de control disponibles según el código ASCII. {| class="wikitable col2cen col4cen" |+Mapa caracteres Tabla ASCII !Simbolo!!dec!!Significado!!Arduino |- ||NULL||0||Caracter nulo||\0 |- ||SOH||1||Start of Heading||\1 |- ||STX||2||Start of text||\2 |- ||ETX||3||End of Text|| |- ||EOT||4||End Of Transmision|| |- ||ENQ||5||Enquiry|| |- ||ACK||6||Ackmowledge|| |- ||BEL||7||Bell||\a |- ||BS||8||Backspace|| |- ||HT||9||Horizontal Tabulation||\t |- ||LF||10||Line Feed||\n |- ||VT||11||Vertical Tabulation||\v |- ||FF||12||Form Feed||\f |- ||CR||13||Carriege Return||\r |- ||SO||14||Shift Out|| |- ||SI||15||Shift In|| |- ||DLT||16||Data Link Escape|| |- ||DC1||17||Device Control 1 (XON)|| |- ||DC2||18||Device Control 2|| |- ||DC3||19||Device Control 3|| |- ||DC4||20||Device Control 4|| |- ||NAK||21||Negative Acknowledge|| |- ||SYN||22||Synchromous Idle|| |- ||ETB||23||End of Transmission Block|| |- ||CAN||24||Cancel|| |- ||EM||25||End of Medium|| |- ||SUB||27||Substitule|| |- ||ESC||27||Escape|| |- ||FS||28||File Separator|| |- ||GS||29||Group Separator|| |- ||RS||30||Record Separator|| |- ||US||31||Unit Separator|| |- ||SP||32||Space|| |- ||DEL||127||Delete|| |} <pre> const char NUL = '\0'; //Tambien '\x000 const char STX = '\2'; //Tambien '\x002 const char ETX = '\x003'; const char BEL = '\a'; //Tambien '\x007 const char LF = '\n'; //Tambien '\x010 const char CR = '\r'; //Tambien '\x013 </pre> == Salida == {| class="wikitable" |+Mapa caracteres Tabla ASCII !Simbolo!!dec!!hex!!oct!!bin |- |!||33||0x21||41||B100001 |- |"||34||0x22||42||B100010 |- |#||35||0x23||43||B100011 |- |$||36||0x24||44||B100100 |- |%||37||0x25||45||B100101 |- |&||38||0x26||46||B100110 |- |'||39||0x27||47||B100111 |- |(||40||0x28||5||B101000 |- |)||41||0x29||51||B101001 |- |<nowiki>*</nowiki>||42||2A||52||B101010 |- |<nowiki>+</nowiki>||43||2B||53||B101011 |- |,||44||2C||54||B101100 |- |<nowiki>-</nowiki>||45||2D||55||B101101 |- |.||46||0x2E||56||B101110 |- |/||47||0x2F||57||B101111 |- |0||48||0x30||60||B110000 |- |1||49||0x31||61||B110001 |- |2||50||0x32||62||B110010 |- |3||51||0x33||63||B110011 |- |4||52||0x34||64||B110100 |- |5||53||0x35||65||B110101 |- |6||54||0x36||66||B110110 |- |7||55||0x37||67||B110111 |- |8||56||0x38||70||B111000 |- |9||57||0x39||71||B111001 |- |:||58||0x3A||72||B111010 |- |;||59||0x3B||73||B111011 |- |<||60||0x3C||74||B111100 |- |=||61||0x3D||75||B111101 |- |>||62||0x3E||76||B111110 |- |?||63||0x3F||77||B111111 |- |@||64||0x40||100||B1000000 |- |A||65||0x41||101||B1000001 |- |B||66||0x42||102||B1000010 |- |C||67||0x43||103||B1000011 |- |D||68||0x44||104||B1000100 |- |E||69||0x45||105||B1000101 |} == Advertencias == * El monitor serie '''nunca''' en via CR (\r) ni LF (\n), al dar enter simplemente envia la cadera sin introducir caracarteres adicionales. == Ejemplo == El monitor serie solo puede interpretar los caracteres entre 33~126. <syntaxhighlight lang="c++"> void setup() { Serial.begin(115200); while (!Serial) { ; //Espera que se conecte el puerto USB nativo. } Serial.println("Mapa tabla ASCII"); for (byte c=33; c>=126; c++){ Serial.write(c); //Imprime el carácter Serial.print(", dec: "); Serial.print(c); //Imprime su valor decimal igual que Serial.print(c, DEC); Serial.print(", hex: "); Serial.print(c, HEX); //Imprime su valor HEX Serial.print(", oct: "); Serial.print(c, OCT); //Imprime su valor OCT Serial.print(", bin: "); Serial.println(c, BIN); //Imprime su valor BIN } } void loop() { //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] nk6b2kk9b549u7x7zpqdwgmdcyu26t6 0 385 4931 4434 2019-09-21T14:30:54Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Los AVR son una familia de microcontroladores (uC) RISC del fabricante estadounidense '''Atmel''', compañía adquirida por '''Microchip Technology''' en 2016. La arquitectura de los AVR fue concebida por dos estudiantes en el Norwegian Institute of Technology, y posteriormente refinada y desarrollada en Atmel Norway, la empresa subsidiaria de Atmel, fundada por los dos arquitectos del chip. Cuenta con bastantes aficionados debido a su diseño simple y la facilidad de programación. == Tipos == Se pueden dividir en los siguientes grupos: ;ATxmega: procesadores muy potentes con 16 a 384 kB de memoria flash programable, encapsulados de 44, 64 y 100 pines (A4, A3, A1), capacidad de DMA, eventos, criptografía y amplio conjunto de periféricos con DACs. ;ATmega: microcontroladores AVR grandes con 4 a 256 kB de memoria flash programable, encapsulados de 28 a 100 pines, conjunto de instrucciones extendido (multiplicación y direccionamiento de programas mayores) y amplio conjunto de periféricos. ;ATtiny: pequeños microcontroladores AVR con 0,5 a 8 kB de memoria flash programable, encapsulados de 6 a 20 pines y un limitado conjunto de periféricos. ;AT90USB: ATmega integrado con controlador USB ;AT90CAN: ATmega con controlador de bus CAN Tipos especiales: algunos modelos especiales, por ejemplo, para el control de los cargadores de baterías, pantallas LCD y los controles de los motores o la iluminación. ;AT90S: tipos obsoletos, los AVRs clásicos == Vea también == * [[PLC]] * [[PIC]] * [[FPGA]] * [[SCADA]] == Referencias == [[Category:Placas]] sbt934xyg412mxyobeaw17t02gzmkfj 0 225 3708 3707 2019-05-06T21:54:37Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Analogico</categorytree> [[Category:Analogico]] m516tdkgjsj12e1m6uo3gnn3wwz7nzc 0 224 3709 991 2019-05-06T21:55:00Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Analogico</categorytree> == Referencias == [[Category:Analogico]] 2i9mmc2o0iyv8al1yd55kjmy3kjkj6x 0 149 3699 1140 2019-05-06T21:48:46Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Este ejemplo muestra cómo leer entradas analógicas del mundo físico usando un potenciómetro. Un potenciómetro es un dispositivo mecánico simple que proporciona una cantidad variable de resistencia cuando se gira el eje. Al pasar la tensión a través de un potenciómetro y a una entrada analógica en su placa, es posible medir la cantidad de resistencia producida por un potenciómetro para un valor analógico. En este ejemplo, usted monitoreará el estado de su potenciómetro después de establecer una comunicación serial entre su Arduino o Genuino y su computadora con el software Arduino (IDE). == Circuito == Conecte un potenciómetro de 10K con sus extremos a GND y +5V respectivamente. El centro del potenciometro al pin analogico A0. == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> void setup() { Serial.begin(115200); } void loop() { int sensor = analogRead(A0); Serial.println(sensor); delay(1); } </syntaxhighlight> == Comentarios == * Nota que NO es necesario usar [[pinMode()]]. == Vea también == <categorytree mode=all>Basicos</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/AnalogReadSerial Ejemplos incluidos] [[Category:Basicos]] 7vf99pm21wvegblqkhnb4bv2e20xs0g 0 226 3710 993 2019-05-06T21:55:24Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Analogico</categorytree> == Referencias == [[Category:Analogico]] 0uoq8tayyx091vs2dgniwnhkb9p7nwc 0 387 4930 4822 2019-09-21T14:29:26Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Es un [[PLC]] desarrollado por la empresa [https://www.industrialshields.com Industrial Shields], basado en un Arduino Mega original añadiendole algunos estandares industriales. [https://www.industrialshields.com Industrial Shields] nace en OCT-2012 de la mano de Albert Prieto, un ingeniero que búsca [[PLC]] más flexibles y a un mejor costo, por lo que decidió desarrollar su propia solución usando Open Source Hardware. Por lo tanto Industrial Shields es la marca que identifica el hardware libre que a la vez sigue parámetros de '''diseño, uso y seguridad industriales''', uniendo lo mejor de dos mundos que hasta ahora avanzaban por separado. == Caracteristicas == * Dispositivo industrial listo para tensión de alimentación de 5, 12 o 24 Vdc. * Fuentes de poder industriales * Caja para instalar en carril DIN * Borneras terminales extraibles DIN con tornillos o resorte. * USB, puerto serie, [[RS-232]], [[RS-485]], [[Wire|I2C]], [[SPI]] y comunicación para codificación, envío/recepción de datos y múltiples módulos y conexiones de sensores. * Cumple todas las normativas para la automatización industrial. Compatibilidad electromagnética, CE, Rohs, etc. == Vea también == * [[PLC]] * [[FPGA]] * [[AVR]] * [[PIC]] * [[SCADA]] * [[OPC]] == Referencias == * [https://www.youtube.com/watch?v=joWU2smQ2LU PLC Arduino Ardbox Relay (20 IOs Controller)] * [https://www.youtube.com/watch?v=smEqOvNvhec&list=PLdaTsV_c5c7UzJSDFPb-0za9w4h6LBgbw Testing a servo motor with an Arduino based Industrial Controller] * [https://youtu.be/3bwDiIV09yE PLC vs Arduino] * [https://store.arduino.cc/usa/plc-arduino-ardbox-plc-20-i-os-relay-hf PLC Arduino ArdBox 20] - Industrial Shields * [https://industruino.com/ Industrino] * [https://www.controllino.biz/ Controllino] [[Category:Placas]] 6a48p8quj9r02xvlgs816e2p0n7zdoj 0 244 3754 3753 2019-05-06T22:16:48Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Esta variación en el ejemplo For Iop de iteración muestra cómo usar una matriz. Una matriz es una variable con varias partes. Si piensas en una variable como una taza que contiene valores, podrías pensar en una matriz como una bandeja de cubitos de hielo. Es como una serie de tazas vinculadas, todas las cuales pueden tener el mismo valor máximo. El ejemplo For Iop de iteración muestra cómo encender seis (6) LED conectados a los pines 2 a 7 de la placa Arduino o Genuino, con ciertas limitaciones (los pines deben numerarse contiguamente, y los LED deben encenderse en secuencia). Este ejemplo muestra cómo puede activar una secuencia de pines cuyos números no son contiguos ni necesariamente secuenciales. Para hacer esto, puede poner los números de pin en una matriz y luego usar los bucles para iterar sobre la matriz. Esta técnica de poner los pines en una matriz es muy útil. No tiene que tener los pines secuenciales entre sí, o incluso en el mismo orden. Los puedes reorganizar en el orden que desee. == Placa aplicable == Todas. == Código == En este ejemplo usa 6 LED conectado cada ánodo via resistencia de 220 ohms a los pines digitales 2~7 pero de manera desordenada. Los cátodos están todos a GND. Note que aquí el orden de los LED está determinado la matriz y no por su orden físico. <syntaxhighlight lang="c++"> const byte led[] = {2, 7, 4, 6, 5, 3}; //Pines de cada LED const byte tot = sizeof(led); //Numero de LEDs const byte tiempo = 300; //Retardo void setup() { for (byte n=0; n<tot; n++) { pinMode(led[n], OUTPUT); } } void loop() { //Ascendente for (byte n=0; n<tot; n++) { digitalWrite(led[n], HIGH); //Prende LED delay(tiempo); digitalWrite(led[n], LOW); //Apaga LED } //Descendente for (byte n=tot-1; n>=0; n--) { digitalWrite(led[n], HIGH); //Prende LED delay(tiempo); digitalWrite(led[n], LOW); //Apaga LED } } </syntaxhighlight> == Comentarios == * La función [[sizeof()]] nos descubre el numero de LEDs por el numero de pines definidos en la matriz '''led[]''' pero tenga en cuenta que el primer elemento de la matriz es 0 y el ultimo es el numero de elementos - 1. == Vea también == <categorytree mode=all>Estructuras de control</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/Arrays Ejemplos de Arduino] [[Category:Estructuras de control]] 5gd44vg4woc0kwhpjuu1bay48v2trxp 0 380 5286 5285 2020-04-01T14:53:00Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == El operador ternario '''?''' es una manera simple de, a través de una condición, elegir entre dos expresiones. == Sintaxis == <pre> condición ? verdadero : falso </pre> == Parametros == ;condicion:Aqui va la condición a evaluar. ;verdadero:Comando a ejecutar si la condición resulta verdadera. ;falso:Comando a ejecutar si la condición resulta false. == Retorno == Luego de evaluar la condición, responderá con la opción verdadera o falsa. == Advetencias == Ninguna. == Ejemplo 1 == Podemos usar la '''Asignación condicional''' dentro de println() <syntaxhighlight lang="c++"> estado = digitalRead(pin); //lectura de botón Serial.println(estado?"Esta en ON":"Esta en OFF"); </syntaxhighlight> == Ejemplo 2 == En este ejemplo revisamos e imprimimos cada segundo el estado de los pines digitales: 2 al 13. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); for (byte n=2; n<14; n++){ pinMode(n, INPUT); } } void loop(){ for (byte n=2; n<14; n++){ Serial.print(n); Serial.print(" = "); Serial.println(digitalRead(n)?"Prendido":"Apagado"); } Serial.println("---------"); delay(1000); } </syntaxhighlight> == Vea también == <categorytree mode=all>Estructura control</categorytree> == Referencias == * [https://picandocodigo.net/2009/operador-ternario-operador-condicional/ Operador ternario condicional] - Picando código [[Category:Estructura control]] 7j2s5372mnka90o2wkqnhd5rgln7rly 0 250 1028 1025 2018-06-26T21:16:27Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Row column scanning]] [[Category:Pantalla]] 7hf0wiay2r5c4vnx3285wze7uesyv36 0 146 3894 3703 2019-05-12T21:56:22Z Kike GL 2 /* Comentarios */ wikitext text/x-wiki Este ejemplo contiene el mínimo de código que necesita para que un boceto se compile correctamente en el software de Arduino (IDE): las funciones [[setup()]] y [[loop()]]. == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> void setup( ) { //pone aquí su código de configuración, para ejecutarlo una vez. } void loop( ) { //pone su código principal aquí, para ejecutarlo repetidamente. } </syntaxhighlight> == Comentarios == * La función [[setup()]] se invoca cuando se inicia un boceto. Úselo para inicializar variables, modos de pin con [[pinMode()]], comenzar a usar bibliotecas, etc. La función de configuración solo se ejecutará una vez, después de cada encendido o restablecimiento de la placa. * La función [[loop()]] hace exactamente lo que su nombre sugiere, ciclos consecutivos, lo que permite que su boceto cambie y responda mientras se ejecuta. El código en la la sección [[loop()]] de su boceto se usa para controlar activamente en la placa Arduino. * El código a continuación no hará nada, pero su estructura es útil para copiar y pegar para que pueda comenzar con cualquier [[boceto]] propio. También le muestra cómo hacer comentarios en su código. * Cualquier línea que comience con dos barras (//) no será leída por el compilador, por lo que puede escribir lo que desee después de ella. Las dos barras pueden colocarse después del código funcional para mantener los comentarios en la misma línea. Comentar su código de esta manera puede ser particularmente útil para explicar, tanto a usted como a los demás, cómo funciona su programa paso a paso. == Vea también == <categorytree mode=all>Basicos</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/BareMinimum Ejemplos incluidos] [[Category:Basicos]] k0t45ysbz8yeh1ogey27sbahl7pq575 0 145 3701 3700 2019-05-06T21:51:06Z Kike GL 2 wikitext text/x-wiki Este ejemplo muestra lo más simple que puede hacer con un Arduino para ver la salida física: parpadea el LED de a bordo. == Funcionamiento == Enciende un LED por un segundo, luego lo apaga por un segundo, repetidamente. == Placa aplicable == La mayoría de los Arduinos tienen un LED integrado que puedes controlar. En UNO, MEGA y ZERO está conectado al pin digital 13, en MKR1000 en el pin 6. LED_BUILTIN está configurado en el pin correcto del LED independientemente de qué placa que se use. Si desea saber a qué pin está conectado el LED de a bordo en su modelo Arduino, consulte las [https://www.arduino.cc/en/Main/Products Especificaciones técnicas]. == Comentarios == * En el ejemplo 2 nota que digitalRead(led) lee el estado actual del LED osea HIGH o LOW, pero recuerda que HIGH es sinonimo de [[true/false|verdadero]] y LOW sinonimo de [[true/false|falso]]. * Seria lo mismo que poner if (digitalRead(led) == HIGH). * Mientras se cumple el tiempo de '''delay(500)''' el uC no puede ejecutar otras tareas como leer un sensor o cambiar una salida digital, pro lo que por lo general '''NO SE RECOMIENDA''' el uso de [[delay()]] de mas de 15 milisegundos y en su lugar se recomienda el usao de [[millis()]]. Ver ejemplo [[Blink without delay]]. == Código 1 == En este ejemplo parpadea el LED a bordo. <syntaxhighlight lang="c++"> void setup() { pinMode(LED_BUILTIN, OUTPUT); } void loop() { digitalWrite(LED_BUILTIN, HIGH); //Prende LED (tension alta, HIGH) delay(500); //Espera medio segundo digitalWrite(LED_BUILTIN, LOW); //Apaga LED (tension baja, LOW) delay(500); //Espera medio segundo } </syntaxhighlight> == Código 2 == En este ejemplo deberás poner un LED con una resistencia de 330 ohms entre el pin 7 y... ;GND: el LED prende cuando pin 7 esta en HIGH. ;+5V: el LED prende cuando pin 7 esta en LOW. <syntaxhighlight lang="c++"> const byte led = 7; void setup() { pinMode(led, OUTPUT); } void loop() { if (digitalRead(led)){ digitalWrite(led, LOW); //Prende LED (tension baja, LOW) }else{ digitalWrite(led, HIGH); //Prende LED (tension alta, HIGH) } delay(500); //Espera medio segundo } </syntaxhighlight> == Vea también == <categorytree mode=all>Basicos</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/Blink Ejemplos incluidos] [[Category:Basicos]] mfivmpvqru8v3intqjzoletwq5vyoc5 0 152 4666 4665 2019-07-07T01:02:54Z Kike GL 2 /* Vea también */ wikitext text/x-wiki A veces necesitas hacer dos cosas a la vez. Por ejemplo, es posible que desee parpadear un LED mientras lee un pulsador o sensor. En este caso, no puede usar [[delay()]], porque Arduino pausa su programa durante el [[delay()]]. Si se presiona el pulsador o cambia el valor del sensor o llega algo por el puerto serie mientras Arduino está en pausa esperando que delay() termine, su programa perderá dicho evento. Este boceto muestra cómo hacer parpadear un LED sin usar [[delay()]]. Enciende el LED y luego toma nota de la '''hora'''. Luego, cada vez que termina [[loop()]] se vuelve a ejecutar y verifica si ha pasado el '''intervalo''' de parpadeo deseado. Si paso, enciende o apaga el LED y toma nota de la nueva '''hora'''. De esta forma, el LED parpadea continuamente mientras que la ejecución del boceto nunca se detiene en una sola instrucción. Una analogía sería calentar una pizza en un microondas y también ver un partido por TV. Pones la pizza en el microondas para calentar durante 10 minutos. La analogía del uso [[delay()]] sería sentarse frente al microondas mirando la cuenta atrás del temporizador desde 10 minutos hasta que el temporizador llegue a cero. Mientras tanto puede que ya metieran un gol y te lo perderás. Lo que harías en la vida real sería encender el microondas y luego regresar a ver el partido. Hasta que la alarma suena avisandote que la pizza esta lista. == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> bool led = true; //Estado del LED unsigned long hora = 0; //Hora de cambio de estado const int intervalo = 500; //Intervalo de parpadeo (millisegundos) void setup() { pinMode(LED_BUILTIN, OUTPUT); } void loop() { if (millis() - hora >= intervalo) { hora = millis(); digitalWrite(LED_BUILTIN, led); led = !led; } } </syntaxhighlight> == Comentarios == * Nuevamente comentarte que verdadero es sinónimo de HIGH y falso es sinónimo de LOW. * La variable '''hora''' debe ser del tipo [[unsigned long]] para poder soportar el retorno de la función [[millis()]] * Ya que '''intervalo''' no cambiara durante la ejecucion la hacemos [[const]] para no ocupar RAM. == Vea también == <categorytree mode=all>Ejemplo Digital</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/BlinkWithoutDelay Ejemplos incluidos] [[Category:Ejemplo Digital]] q5cl7u32pi7bf62w6iyg0cghnxeiuj9 0 413 3299 3298 2019-05-04T23:33:19Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == La librería [https://github.com/thomasfredericks/Bounce2/wiki Bounce2.h] de Thomas Frefericks que esta en el gestos de librerias del [[IDE]]. {{Nota|Para saber mas del efecto Rebote.}} == Placas aplicables == == Sintaxis == <pre> #include <Bounce2.h> Bounce rebote = Bounce(); rebote.attach(pin); rebote.interval(pausa); </pre> == Parametros == ;pin:pin del pulsador. ;pausa:Valor de retardo. == Métodos == {| class="wikitable" |+Metodos disponibles en libreria Bounce2.h |- ! Método !! Descripción |- | rebote.attach(pin) || Asigna el pin |- | rebote.interval(pausa) || Asigna el tiempo en milisegundos |- | rebote.update() || Debido a que Bounce no usa interrupciones, debe "actualizar" el objeto antes de leer su valor y debe hacerlo con la mayor frecuencia posible (eso significa incluirlo en su bucle loop()). El método update() actualiza el objeto y devuelve verdadero (1) si el estado del pin cambia. Falso (0) si no. Solo llame a update() una vez por loop(). |- | rebote.read() || Lee el estado del pin luego de update(). |- | rebote.fell() || Devuelve true si las transiciones de señal del pin es de HIGH a LOW (falling). |- | rebote.rose() || Devuelve true si las transiciones de señal del pin es de LOW a HIGH (rissing). |} == Comentarios == == Advertencias == == Ejemplo 1 == El ejemplo basico, un solo pulsador en pin 2. <syntaxhighlight lang="c++"> #include <Bounce2.h> #define PIN 2 #define LED 13 Bounce rebote = Bounce(); //Instancia objeto void setup() { pinMode(PIN, INPUT_PULLUP); rebote.attach(PIN); //Cuando ya esta definido el pin rebote.interval(5); pinMode(LED, OUTPUT); } void loop() { rebote.update(); //Actualiza bool valor = rebote.read(); if (valor) { digitalWrite(LED, LOW); //Apaga LED }else{ digitalWrite(LED, HIGH); //Prende LED } } </syntaxhighlight> == Ejemplo 2 == En este ejemplo configuramos 8 pines. <syntaxhighlight lang="c++"> #include <Bounce2.h> #define LED 13 #define NUM 8 const byte PULSADOR[NUM] = {2, 3, 4, 5, 6, 7, 8, 9}; Bounce * boton = new Bounce[NUM]; //Instancia todos los pines void setup() { for (byte i=0; i<NUM; i++) { boton[i].attach(PULSADOR[i], INPUT_PULLUP); boton[i].interval(25); } pinMode(LED, OUTPUT); } void loop() { for (byte i=0; i<NUM; i++) { boton[i].update(); //Actualiza if (boton[i].fell()) { digitalWrite(LED, !digitalRead(LED)); //Conmuta LED } } } </syntaxhighlight> == Ejemplo 3 == Muestra los milisegundos entre dos pulsaciones. <syntaxhighlight lang="c++"> #include <Bounce2.h> #define BOTON 2 Bounce rebote = Bounce(); unsigned long tiempo = 0; void setup() { Serial.begin(57600); pinMode(BOTON, INPUT_PULLUP); rebote.attach(BOTON); rebote.interval(5); } void loop() { rebote.update(); if (rebote.fell()) {; Serial.println(millis()-tiempo); tiempo = millis(); } } </syntaxhighlight> == Ejemplo 4 == Muestra cuando el boton el presionado y soltado. Ademas si lo mantienes presionado te da un mensaje cada medio segundo. <syntaxhighlight lang="c++"> #include <Bounce2.h> #define BOTON 2 #define LED 13 Bounce rebote = Bounce(); unsigned long tiempo = 0; bool valor = false; void setup() { Serial.begin(57600); pinMode(BOTON, INPUT_PULLUP); rebote.attach(BOTON); rebote.interval(5); pinMode(LED, OUTPUT); } void loop() { if (rebote.update()) { if (rebote.read()){ digitalWrite(LED, LOW); Serial.println("Boton soltado (HIGH)"); valor = false; }else{ digitalWrite(LED, HIGH); Serial.println("Boton presionado (LOW)"); tiempo = millis(); valor = true; } } if (valor) { if (millis()-tiempo >= 500) { tiempo = millis(); digitalWrite(LED, LOW); Serial.println("Boton reactivado"); } } } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] * [https://playground.arduino.cc/Code/Bounce/ Bounce2] [[Category:Librerias]] i70y2w6mzcghkrp4b53y4rxkyogr0aq 0 153 4668 4667 2019-07-07T01:03:57Z Kike GL 2 /* Referencias */ wikitext text/x-wiki Los pulsadores conectan dos puntos en un circuito cuando los presiona. Este ejemplo enciende el LED a bordo mientras presiona el pulsador. Como si fuera un timbre. == Placa aplicable == Todas. == Circuito == * Conecta un pulsador entre el pin 2 y GND. == Código == <syntaxhighlight lang="c++"> const byte pulsador = 2; void setup() { pinMode(LED_BUILTIN, OUTPUT); pinMode(pulsador, INPUT_PULLUP); } void loop() { if (digitalRead(pulsador)) { digitalWrite(LED_BUILTIN, LOW); //Apaga LED si sueltas pulsdor }else{ digitalWrite(LED_BUILTIN, HIGH); //Prende LED si presionas pulsador } } </syntaxhighlight> == Comentarios == * Mientras el pulsador no esta presionado en el pin 2 tenemos un HIGH gracias a la resistencia PULL-UP interna que esta activada desde [[pinMode()]]. * Cuando pulsas se pasa GND al pin 2, osea LOW y la condicion del if() es false por lo que se prende el LED. == Vea también == <categorytree mode=all>Ejemplo Digital</categorytree> == Referencias == [[Category:Ejemplo Digital]] 1hx4gvzguzl2zfyqz33y4w18un4czkc 0 279 1060 2018-06-26T21:33:22Z Kike GL 2 Página creada con « == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Joystick mouse control]] Category...» wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Joystick mouse control]] [[Category:Mouse]] n5wdddmja18931kqn1nzmuke07x5zr6 0 190 3791 3781 2019-05-06T23:00:43Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Se usan para expresar (en código fuente) la manera en que una interrupción externa debe dispararse. == Sintaxis == <pre> attachInterrupt(digitalPinToInterrupt(pin), ISR, modo); //recomendado attachInterrupt(interrupt, ISR, modo); //no recomendado attachInterrupt(pin, ISR, modo); //Solo en Arduino Due, Zero, MKR1000 y 101. </pre> == Parámetros == ;pin: pin asociado a la interrupcion ;modo: define el trigger (disparador) que puede ser: LOW (mientras se mantenga en estado bajo), CHANGE (apenas el estado cambie), RISING (después de la transición del estado bajo al alto), FALLING (después de la transición del estado alto al bajo) o HIGH (mientras se mantenga en estado alto, sólo en Due). ;ISR: Funciones de usuario. == Retorno == Nada. == Advertencias == Nada. == Ejemplos == <pre> const byte pulsador = 2; volatile byte estado = LOW; void setup() { pinMode(LED_BUILTIN, OUTPUT); pinMode(pulsador, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(botonPin), cambia, CHANGE); } //Función de interrupción (ISR) void cambia() { estado = !estado; } void loop() { digitalWrite(LED_BUILTIN, estado); }</pre> == Vea también == <categorytree mode=all>Palabras reservadas</categorytree> == Referencias externas == [[Category:Palabras reservadas]] gxq6bs28zxl9f7q6xtrjdar1trwva96 0 227 3711 994 2019-05-06T21:56:01Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Analogico</categorytree> == Referencias == [[Category:Analogico]] 2i9mmc2o0iyv8al1yd55kjmy3kjkj6x 0 482 4796 2019-07-18T17:02:28Z Kike GL 2 Página creada con «Esta es la categoría principal de ArduWiki.» wikitext text/x-wiki Esta es la categoría principal de ArduWiki. bamwnl9rhisaqwi44hnakp4m6wz4a89 0 141 4088 3183 2019-05-30T23:52:32Z Kike GL 2 wikitext text/x-wiki Un servidor simple que distribuye los mensajes entrantes a todos los clientes conectados. Para usarlo, abra una ventana de terminal, Telnet a la dirección IP de su dispositivo y escriba algo. Cualquier texto entrante se enviará a todos los clientes conectados (incluido el que escribe). Además, también podrá ver las entradas del cliente en su monitor de serie. == Ejemplo == <syntaxhighlight lang="c++"> #include <SPI.h> #include <Ethernet.h> // Enter a MAC address and IP address for your controller below. // The IP address will be dependent on your local network. // gateway and subnet are optional: byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; IPAddress ip(192, 168, 1, 177); IPAddress myDns(192,168,1, 1); IPAddress gateway(192, 168, 1, 1); IPAddress subnet(255, 255, 0, 0); // telnet defaults to port 23 EthernetServer server(23); boolean alreadyConnected = false; // whether or not the client was connected previously //Ethernet shield attached to pins 10, 11, 12, 13 void setup() { Serial.begin(9600); Ethernet.begin(mac, ip, myDns, gateway, subnet); server.begin(); Serial.print("Chat server address:"); Serial.println(Ethernet.localIP()); } void loop() { // wait for a new client: EthernetClient client = server.available(); // when the client sends the first byte, say hello: if (client) { if (!alreadyConnected) { // clear out the input buffer: client.flush(); Serial.println("We have a new client"); client.println("Hello, client!"); alreadyConnected = true; } if (client.available() > 0) { // read the bytes incoming from the client: char thisChar = client.read(); // echo the bytes back to the client: server.write(thisChar); //echo the bytes to the server as well: Serial.write(thisChar); } } } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria Ethernet</categorytree> == Referencias externas == [[Category:Libreria Ethernet]] j0195aoy9g2kwdtd5ica1fr19wa7ixx 0 259 3724 1037 2019-05-06T22:03:00Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 203 2834 2709 2019-03-28T16:12:00Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Se usa para poner comentarios de autor. Serán ignorados por el compilador. == Sintaxis == <pre> //comentario corto /* comentario de varias filas */ </pre> == Retorna == Nada. == Ejemplos == <syntaxhighlight lang="c++"> /*Los autores de este ArduWiki son valuntario*/ //De lo major </syntaxhighlight> == Vea también == * [[Palabras reservadas]] * [[Estructura]] * [[setup()]] * [[loop()]] == Referencia == * [https://www.arduino.cc/reference/en/language/structure/further-syntax/singlelinecomment/ Guia de referencia] [[Category:Estructura]] 7ak3c0jjsujrlyjmx03kxa6a7eha736 0 289 2248 2247 2018-07-25T17:20:06Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Durante el desarrollo, todos usamos [[Serial.print()]] para ayudar a depurar nuestro código. Cuando las cosas parecen estables, volvemos y eliminamos el código de depuración... solo para descubrir unos días después que necesitamos nuevamente el código de depuración. Una buena solucion es dejar todo el código de depuración donde corresponde y solo modificar esta linea: == Sintaxis == <pre> #define DEBUG #ifdef DEBUG Serial.print("Algunas cosas de depuración"); //Más código de depuración ... #endif </pre> Para desactivas solo comente la primera linea: <pre> //#define DEBUG #ifdef DEBUG Serial.print("Algunas cosas de depuración"); //Más código de depuración ... #endif </pre> == Comentarios == Cuando comentar la primera linea logras que uC defina que DEBUG desaparezca comentándolo. Como ya no está definido en el programa, cualquier elemento entre el #ifdef y el #endif ya no forma parte del archivo fuente desde el punto de vista del compilador. Esto facilita agregar y eliminar código de depuración. == Ejemplos == <syntaxhighlight lang="c++"> #define DEBUG #ifdef DEBUG #define DEBUG_PRINT(x) Serial.print(x) #define DEBUG_PRINTDEC(x) Serial.print(x, DEC) #define DEBUG_PRINTLN(x) Serial.println(x) #else #define DEBUG_PRINT(x) #define DEBUG_PRINTDEC(x) #define DEBUG_PRINTLN(x) #endif </syntaxhighlight> == Ejemplo 1 == Imprimir una matriz <syntaxhighlight lang="c++"> #define DEBUG_ARRAY(a) { for (int index=0; index<sizeof(a)/sizeof(a[0]); index++){ Serial.print(a[index]); Serial.print('\t'); } Serial.println(); }; String str = ""; const chr separador = ','; const byte largo = 3; int datos[largo]; void setup(){ Serial.begin(115200); } void loop(){ if (Serial.available()){ str = Serial.readStringUntil('\n'); for (byte i=0; i<largo ; i++){ int indice = str.indexOf(separador); datos[i] = str.substring(0, indice).toInt(); str = str.substring(indice + 1); } DEBUG_ARRAY(data); } } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> #define DEBUG(a) Serial.println(a); String texto = "-123.45"; void setup(){ Serial.begin(9600); float valor = texto.toFloat(); DEBUG(valor); } void loop(){ //Nada. } </syntaxhighlight> == Vea también == * [[flash]] * [[SRAM]] * [[EEPROM]] == Referencias == * [https://forum.arduino.cc/index.php?topic=46900.0 Foro Arduino] [[Category:Estructura]] jvuhq0oxws4subordaeud3rt7tmpo0g 0 290 3787 3786 2019-05-06T22:58:27Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Palabras reservadas que representan los sistemas numéricos. == Sintaxis == <pre> Serial.print(variable[, tipo]); Serial.println(variable[, tipo]); </pre> == Parámetros == ;variable: Variable a evaluar. ;tipo: indica el tipo de salida. Por omision es DEC, pero puedes usar BIN, HEX u OCT. Parámetro Opcional. == Retorno == Retorna la variable en el formato numérico solicitado == Advertencias == * Nota que DEC, HEX, OCT y BIN se debe escribir en mayusculas. == Ejemplos == <syntaxhighlight lang="c++"> byte n = 'A'; Serial.write(n); //A Serial.println(n); //65 Serial.println(n, DEC); //65 Serial.println(n, HEX); //41 Serial.println(n, OCT); //101 Serial.println(n, BIN); //1000001 </syntaxhighlight> == Vea también == <categorytree mode=all>Palabras reservadas</categorytree> == Referencias == [[Category:Palabras reservadas]] 8znld4yxc30709nbjjkfpuuf449k46y 0 359 5139 5129 2020-01-23T16:44:55Z Kike GL 2 /* Ejemplo 2 */ wikitext text/x-wiki == Descripción == La libreria '''RTClib.h''' agrega la funcionanlidad de reloj al Arduino, con o sin hardware externo. Permite que un [[boceto]] obtenga la fecha y hora actual. También proporciona tiempo estándar '''DateTime'''. DateTime es una clase simple de fecha hora de uso general sin TZ/DST. == Sintaxis == <pre> #include <RTClib.h> DateTime variable (año,mes,dia,hora,min,seg); DateTime variable (segundos totales); </pre> == Parametros == ;variable: ;año: 4 digitos del año. ;mes: 2 digitos del mes entre 1~12. ;dia: 2 digitos del dia entre 1~31. ;hora: 2 digitos de la hora entre 0~23. ;min: 2 digitos de los minutos entre 0~59. ;seg: 2 digitos de los segundos entre 0~59. ;segundos totales:segundos desde 1-ENE-1970 == Retorna == Nada. == Métodos == {| class="wikitable" |+Métodos disponibles clase DateTime |- ! Método !! Descripción |- | year() || Año |- | month() || Mes (1~12) |- | day() || Dia (1~31) |- | hour() || Horas (0~23) |- | minute() || Minutos (0~59) |- | second() || Segundos (0~59) |- | dayOfTheWeek() || Dia de la semana (0=domingo) |- | secondstime() || Segundos desde 1-ENE-2000 |- | unixtime() || Segundos desde 1-ENE-1970 |- | timestamp() || Formato "2020-01-01T08:00:00 |} == Comentarios == Nada. == Advertencias == Nada. == Ejemplo 1 == Si usas la librería [[RTC|RTClib.h]] tendrás disponible el método '''.unixtime()''' que es excelente para hacer operaciones con fechas. <syntaxhighlight lang="c++"> DateTime t0 (2018,7,14,8,0,0); //2018-7-14 8:00:00 //Calculos 1 DateTime t1 = t0 + TimeSpan(0,1,0,0); //Añadir una hora DateTime t2 = t0 + TimeSpan(1,0,0,0); //Añadir un dia DateTime t3 = t0 - TimeSpan(7,0,0,0); //Restar una semana //Calculos 2 DateTime unix = t0.unixtime(); //1531555200 DateTime t1 (t0.unixtime() + 3600); //Añadir una hora DateTime t2 (t0.unixtime() + 86400L); //Añadir un dia DateTime t3 (t0.unixtime() - 7*86400L); //Restar una semana //Mostrar Serial.print(t0.unixtime()); //1531555200 Serial.print(t0.year()); //2018 Serial.print(t0.month()); //7 Serial.print(t0.day()); //14 Serial.print(t0.hour()); //8 Serial.print(t0.minute()); //0 Serial.print(t0.second()); //0 </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> //#include <Wire.h> #include <RTClib.h> RTC_Millis rtc; //Reloj por software //RTC_DS1307 rtc; //Reloj con DS1307 //RTC_DS3231 rtc; //Reloj con DS3231 char diaSemana[7][12] = {"Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado"}; void setup () { Serial.begin(57600); //Para setear RTC con fecha y hora cuando se compila rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); //Para setear RTC a 21-MAR-2019 8:00:00 //rtc.adjust(DateTime(2019, 3, 21, 8, 0, 0)); } void loop () { DateTime hoy = rtc.now(); Serial.print(hoy.year()); Serial.print('-'); Serial.print(hoy.month()); Serial.print('-'); Serial.print(hoy.day()); Serial.print(" ("); Serial.print(diaSemana[now.dayOfTheWeek()]); Serial.print(") "); Serial.print(hoy.hour()); Serial.print(':'); Serial.print(hoy.minute()); Serial.print(':'); Serial.println(hoy.second()); Serial.print("Desde 1-ENE-1970 = "); Serial.print("Segundos = "); Serial.println(hoy.unixtime()); Serial.print("Dias = "); Serial.println(hoy.unixtime() / 86400L); //calcula fecha dentro de 7 dias, 12 horas, 30 minutos y 6 segundos DateTime futuro (hoy + TimeSpan(7,12,30,6)); Serial.print("Fecha furura: "); Serial.print(futuro.year()); Serial.print('-'); Serial.print(futuro.month()); Serial.print('-'); Serial.print(futuro.day()); Serial.print(' '); Serial.print(futuro.hour()); Serial.print(':'); Serial.print(futuro.minute()); Serial.print(':'); Serial.print(futuro.second()); Serial.println(); Serial.println(); delay(3000); } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria RTC</categorytree> == Referencias == * [https://adafruit.github.io/RTClib/html/class_date_time.html Clase DateTime] - Adafruit * [https://github.com/adafruit/RTClib RTClib] - Adafruit [[Category:Libreria RTC]] eb95cct8za6ylprr7nup6xkmt0b63li 0 154 4670 4669 2019-07-07T01:05:03Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki Los pulsadores a menudo generan transiciones falsas de apertura/cierre de contactos cuando se presionan, debido a problemas mecánicos y físicos: estas transiciones se pueden leer como múltiples presiones en un tiempo muy corto engañando al programa. Este ejemplo muestra cómo eliminar el rebote de una entrada, lo que significa verificar dos veces en un corto período de tiempo para asegurarse de que el botón esté definitivamente presionado. Sin reblandecimiento, presionar el botón una vez puede causar resultados impredecibles. Este boceto usa la funcion [[millis()]] para realizar un seguimiento del tiempo transcurrido desde que se presionó el botón. == Placa aplicable == Todas. == Circuito == Conecta un pulsador entre el pin 2 y GND. == Código == El siguiente boceto está basado en la versión de rebote de Limor Fried. <syntaxhighlight lang="c++"> const byte pin = 2; //Pulsador const byte para = 50; //Tiempo de rebote unsigned long hora = 0; //Hora ultima vez que pulsaste byte led = LOW; //Estado actual del LED byte actual; //Estado actual del pulsador (buttonState) byte anterior = LOW; //Estado anterior del pulsador (lastButtonState) void setup() { pinMode(pin, INPUT_PULLUP); pinMode(LED_BUILTIN, OUTPUT); digitalWrite(LED_BUILTIN, led); } void loop(){ byte lee a digitalRead(pin); ... falta digitalWrite(LED_BUILTIN, led); anterior = lee; } </syntaxhighlight> == Comentarios == * Cada vez que el pin de entrada pasa de HIGH a LOW, el LED prende o apaga según el caso. Hay un retraso mínimo entre los conmutadores para rebotar el circuito (es decir ignorar el ruido). * Al principio el pulsador esta libre por lo que pin 2 esta en HIGH y se guarda en '''lee'''. Luego el primer if() comprueba si hay cambio de estado (lee != anterior), como no hay lo salta. El segundo if() ya que hora=0 entra y pregunta si pulsador sigue igual (lee != actual) y luego de guardar nuevamente dicho estado y pregunta si el estado actual es LOW y como no lo es salta el cuarto if() y guarda la lectura en '''anterior'''. * Ahora presionamos pulsador y pin 2 se pone LOW y se guarda en '''lee'''. Luego el primer if() comprueba si hay cambio de estado y como si hay entra al if() y guarda '''hora'''. Luego va el siguiente if() y aun no paso el tiempo de '''para''' por lo que guarda '''anterior''' como LOW. * EL pulsador sigue presionado por lo que pin 2 sigue LOW por lo que salta el primer if(). Continua haciendo bucles hasta que se cumple '''para''' cuando entra al segundo if(). Entra al tercer if() y guarda '''actual''' entra al cuarto if() y cambia '''led'''. == Vea también == <categorytree mode=all>Digital</categorytree> == Referencias externas == * [https://www.arduino.cc/en/Tutorial/Debounce Ejemplos incluidos] [[Category:Ejemplo Digital]] hrzk5d9rb1j6p486amsquig0uoe9aer 0 155 4672 4671 2019-07-07T01:05:45Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Este ejemplo demuestra el uso de [[pinMode()]] con INPUT_PULLUP. Lee una entrada digital en el pin 2, prende el LED a bordo e imprime los resultados en el monitor de serie. == Circuito == Conecte un pulsador entre el pin digital 2 y GND. == Placa aplicable == Todas == Código == <syntaxhighlight lang="c++"> const byte pin = 2; void setup() { Serial.begin(115200); pinMode(pin, INPUT_PULLUP); pinMode(LED_BUILTIN, OUTPUT); } void loop() { bool pulsador = digitalRead(pin); Serial.println(pulsador); if (pulsador == HIGH) { digitalWrite(LED_BUILTIN, LOW); Serial.println(""LED OFF); }else{ digitalWrite(LED_BUILTIN, HIGH); Serial.println(""LED ON); } } </syntaxhighlight> == Comentarios == * Notese que gracias a la configuración del pin digital 2 (INPUT_PULLUP) este pin esta normalmente en HIGH y pasa a LOW cuando presionar pulsador. * if (pulsador == HIGH) es exactamente lo mismo que if (pulsador) o '''if (ditalRead(pin))'''. == Vea también == <categorytree mode=all>Ejemplo Digital</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/DigitalInputPullup Ejemplos incluidos] [[Category:Ejemplo Digital]] 016v9dyklztds54698nhbi2ybf5tqwc 0 148 3706 1143 2019-05-06T21:53:20Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Este ejemplo muestra cómo controlar el estado del LED a bordo con un pulsador. == Circuito == Conecta == Placa aplicable == Todas. == Código == Con este simple ejemplo gracias a la configuración del pin 2 en INPUT_PULLUP nosrmalmente estara en HIGH a no ser que se presione pulsador que pasa a LOW y prende el LED a bordo. <syntaxhighlight lang="c++"> const byte pulsador = 2 ; void setup(){ Serial.begin(115200); pinMode(LED_BUILTIN, OUTPUT); pinMode(pulsador, INPUT_PULLUP); } void loop(){ bool boton = digitalRead(pulsador); if (boton){ digitalWrite(LED_BUILTIN, LOW); Serial.println("LED OFF"); }else{ digitalWrite(LED_BUILTIN, HIGH); Serial.println("LED ON"); } } </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Basicos</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/DigitalReadSerial Ejemplos incluidos] [[Category:Basicos]] eim8kczvk41yzaejfdf0bfs0boph4y6 0 232 3742 1002 2019-05-06T22:11:28Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 335 4865 4452 2019-09-10T00:14:49Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Es una memoria no volátil para mantener datos después de apagado nuestro Arduino. Se puede grabar constantes desde un [[boceto]] con algunas instrucciones especiales. Al igual que la memoria [[flash]] tiene una vida útil de unas 100,000 ciclos de escritura. Esta memoria solo puede leerse byte a byte y su uso puede se un poco incómodo. También es algo más lenta que la [[SRAM]]. {|class="wikitable col2cen col3cen col4cen" |+Memoria en cada Arduino !Tipo!!Arduino [[UNO]]!!Arduino [[MEGA]]!!Arduino [[MKR1000]] |- |[[flash]]||32K||256K||256K |- |Flash-bootloader||0.5K||8K||- |- |[[SRAM]]||2K||8K||32K |- |EEPROM||1K||4K||- |} Es una libreria [https://github.com/thijse/Arduino-EEPROMEx EEPROM] de Thijs Elenbaas... == Sintaxis == <pre> #include <EEPROM.h> EEPROM.write(dirección, dato); EEPROM.read(dirección); </pre> == Parametros == ;dirección:Es la dirección entre 0 y el total de memoria EEPROM de tu placa. ;dato:Es un valor de un [[byte]]. == Metodos == {| class="wikitable" |+Metodos de EEPROM |- ! Metodo !! Descripciom |- | read() || |- | readByte() || |- | readInt() || |- | readLong() || |- | readDouble() || |- | readBlock() || |- | writeByte() || |- | writeInt() || |- | writeLong() || |- | writeDouble() || |- | writeFloat() || |- | writeBlock() || |- | update() || |- | updateByte() || |- | updateInt() || |- | updateLong() || |- | updateBouble() || |- | updateFloat() || |- | updateBlock() || |- | isReady() || |- | setMemPool() || |- | setMaxAllowedWrites() || |- | getAddress() || |} == Comentarios == * La EEPROM de tu Arduino es especialmente util para guardar datos como: MAC, IP, constantes de calibración de algún sensor y claves de usuario. * Para actuar con esta memoria debes usar la '''libreria EEPROM.h''' que esta por defecto en el IDE. * Debes trabajar con direcciones y hacerlo byte a byte, tanto para leer como para escribir. * Las direcciones van de 0 a 999 y podrás almacenar datos de 0 a 255. Para datos mas grandes debes dividirlos en bytes. Por ejemplo si el dato es tipo [[unsigned int]] lo debes dividir entre 4 y luego de recuperar multiplicar por 4 (pierdes presicion). == Advertencias == * En ESP8266 es distinto [https://arduino.stackexchange.com/questions/25945/how-to-read-and-write-eeprom-in-esp8266 mira aqui]. == Ejemplo 1 == Escribir y leer un solo [[byte]]. <syntaxhighlight lang="c++"> #include <EEPROM.h> int Direccion = 0; //Variable con la posición de memoria void setup(){ //Escribir byte data = B11001; //25 en binario EEPROM.write(Direccion, data); //Leer byte val = EEPROM.read(Direccion); } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == Escribir y leer un dato tipo [[int]] osea dos bytes. <syntaxhighlight lang="c++"> #include <EEPROM.h> void setup(){ //Escribir int dato = 12345; EEPROM.write(0, highByte(dato)); //Toma mas significativo EEPROM.write(1, lowByte(dato)); //Toma menos significativo //Leer int val = EEPROM.read(0); val = val << 8; //Desplaza a la izquierda val += EEPROM.read(1); } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 3 == Escribir y leer un dato tipo [[long]] osea cuatro bytes. <syntaxhighlight lang="c++"> #include <EEPROM.h> void setup(){ //Escribir long dato = 123456789; for (byte i=0; i<4; i++) { EEPROM.write(3-i, lowByte(dato)); dato = dato >> 8; //Desplaza 8 bits a la derecha } //Lee long val = 0; for (byte i=0; i<3; i++) { val += EEPROM.read(i); val = val << 8; //Desplaza 8 bits a la izquierda } val += EEPROM.read(3); } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 4 == Escribir y leer un dato tipo matriz. <syntaxhighlight lang="c++"> #include <EEPROM.h> void setup(){ Serial.begin(9600); //Escribir char data[12] = "Arduino 123"; for (byte i=0; i<13; i++){ EEPROM.write(i, data[i]); } //Leer char val[12]; for (byte i=0; i<13; i++){ val[i] = EEPROM.read(i); } Serial.print(val); } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias == * [https://www.arduinolibraries.info All Librays] * [http://playground.arduino.cc/Code/EEPROMex EEPROMex] * [https://www.luisllamas.es/guardar-variables-entre-reinicios-con-arduino-y-la-memoria-no-volatil-eeprom/ Memoria EEPROM] - Luis Llamas * [http://www.educachip.com/como-usar-la-memoria-eeprom-de-arduino/ Como usar EEPROM] - EducaChip * [https://arduino.stackexchange.com/questions/25945/how-to-read-and-write-eeprom-in-esp8266 EEPROM para ESP8266] * [https://arduinoplusplus.wordpress.com/2019/04/02/persisting-application-parameters-in-eeprom/ Persisting parameters in EEPROM] - Marco_C [[Category:Librerias]] [[Category:memoria]] oiaw0xeesuktdnju7u52hlz7f2xeq6a 0 418 3225 2019-05-03T22:54:30Z Kike GL 2 Página creada con «== Descripción == La librería [https://github.com/adafruit/Adafruit_ESP8266 ESP8266] de Adafruit... == Placas aplicables == == Sintaxis == <pre> </pre> == Métodos ==...» wikitext text/x-wiki == Descripción == La librería [https://github.com/adafruit/Adafruit_ESP8266 ESP8266] de Adafruit... == Placas aplicables == == Sintaxis == <pre> </pre> == Métodos == == Comentarios == == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] [[Category:Librerias]] d6zgiz8sdqnjyoemzmydvs2k51cfni9 0 144 1059 1058 2018-06-26T21:32:13Z Kike GL 2 /* Techado */ wikitext text/x-wiki Los ejemplos incorporados son bocetos incluidos en el software Arduino (IDE), para abrirlos haga clic en el menú de la barra de herramientas: Archivo> Ejemplos. Estos sencillos programas demuestran todos los comandos básicos de Arduino. == Basicos == * [[Bare minimum]] el mínimo código necesario para comenzar un boceto de Arduino. * [[Blink]] enciende y apaga un LED con delay(). * [[Fade]] Demuestra el uso de la salida analógica (PWM) para prender un LED. * [[Digital read serial]] lea un interruptor e imprima su estado en el monitor serie de Arduino. * [[Analog read serial]] lea un potenciómetro e imprima su estado en el monitor serie Arduino. * [[Read analog voltage]] lee una entrada analógica e imprime el voltaje en el monitor serie. == Digital == * [[Blink without delay]] Parpadea un LED sin usar la función delay(). * [[Button]] Usar un botón para controlar un LED. * [[Debounce]] Lee un botón, filtrando el ruido. * [[Digital input pullup]] Demuestra el uso de INPUT_PULLUP en pinMode(). * [[State change detection]] Cuente el número de pulsaciones de botón. * [[Tone keyboard]] Teclado musical de tres teclas que usa sensores de fuerza y ​​un altavoz piezoeléctrico. * [[Tone melody]] Reproduce una melodía con un parlante Piezo. * [[Tone múltiple]] Reproduce tonos en múltiples altavoces secuencialmente usando el comando de tono (). * [[Tone pitch follower]] reproduce un tono en un altavoz piezoeléctrico dependiendo de una entrada analógica. == Analógico == * [[Analog out serial]] Lea un pin de entrada analógica (A0~A5), asigne el resultado y luego use esos datos para atenuar o iluminar un LED. * [[Analog input]] Use un potenciómetro para controlar el parpadeo de un LED. * [[Analog write MEGA]] Enciende y apaga 12 LEDs, uno por uno, usando una placa Arduino MEGA. * [[Calibration]] Defina un máximo y un mínimo para los valores esperados del sensor analógico. * [[Fading]] Usa una salida analógica (PWM) para prender un LED. * [[Smoothing]] Lecturas múltiples suaves de una entrada analógica. == Comunicación == Estos ejemplos incluyen código que permite al Arduino hablar con bocetos de procesamiento que se ejecutan en la computadora. Para obtener más información o descargar Processing, consulte processing.org . También hay parches Max / MSP que pueden comunicarse con cada boceto de Arduino también. Para más información sobre Max / MSP, vea Cycling 74. * [[ASCII table]] Demuestra las funciones avanzadas de salida serie de Arduino. * [[Dimmer]] Mueva el mouse para cambiar el brillo de un LED. * [[Graphic]] Envíe datos a la computadora y grábelos en Processing. * [[Midi]] Envía mensajes de nota MIDI en serie. * [[Multi serial MEGA]] Use dos de los puertos serie disponibles en el Arduino MEGA. * [[Physical pixel]] Enciende y apaga un LED enviando datos a tu Arduino desde Processing o Max / MSP. * [[Read ASCII string]] analiza una cadena de enteros separados por comas para prender un LED. * [[Serial call response]] envíe múltiples variables usando un método de llamada y respuesta (handshaking). * [[Serial call response ASCII]] envíe múltiples variables usando un método de llamada y respuesta (handshaking), y codifique ASCII antes de enviar. * [[Serial event]] Demuestra el uso de la funcion SerialEvent(). * [[Serial passthrough]] Demuestra cómo conectar virtualmente Serial y Serial1. * [[Virtual color mixer]] Envíe múltiples variables desde Arduino a su computadora y léalas en Processing o Max / MSP. == Estructuras de control == * [[If statement conditional]] Usa un '''if()''' para cambiar las condiciones de salida segun las condiciones de entrada. * [[Switch case 1]] cómo elegir entre un número discreto de valores. * [[Switch case 2]] Un segundo ejemplo de switch-case, que muestra cómo tomar diferentes acciones basados en los caracteres recibidos en el puerto serie. * [[For loop iteraction]] Controle varios LED con un bucle for. * [[Arrays]] Una variación en el ejemplo del bucle For que demuestra cómo usar una matriz. * [[While statement conditional]] cómo usar un bucle while para calibrar un sensor mientras se lee un pulsadar. == Sensores == * [[ADXL3xx]] Lea un acelerómetro ADXL3xx. * [[Knock]] Detecta golpes con un elemento piezoeléctrico. * [[Memsic2125]] Acelerómetro de dos ejes. * [[Ping]] Detecta objetos con un telémetro ultrasónico. == Pantalla == * [[Bar graph]] Crea un gráfico de barras LED. * [[Row column scanning]] Controla una matriz de LED de 8x8. == Caracteres == * [[String constructor]] Inicializar objetos de cadenas. * [[Chracter analisis]] Use los operadores para reconocer el tipo de personaje con el que estamos tratando. * [[String addition operation]] Agregue cadenas de una variedad de formas. * [[String append operator]] Use el operador += y el método concat() para agregar cosas a las cadenas. * [[String case changes]] Cambia la mayúscula/minuscula en una cadena. * [[String characters]] Obtiene/establece el valor de un carácter específico en una cadena. * [[String comperison operators]] Compare las cadenas alfabéticamente. * [[String index of]] Busca la primera/última instancia de un carácter en una cadena. * [[String length & string leng trim]] Obtenga y recorte la longitud de una cadena. * [[String Replace]] Reemplaza los caracteres individuales en una cadena. * [[String start with ends with]] Comprueba qué caracteres/subcadenas comienza o termina una cadena determinada. * [[String substring]] busca una subcadena dada dentro la cadena. * [[String to int]] Convierte una cadena en un número entero. == USB == Los ejemplos de teclado y mouse son exclusivos de Leonardo, Micro y Due. Demuestran el uso de bibliotecas que son exclusivas de la junta. === Techado === * [[Keyboard logout]] Cierra la sesión del usuario actual con comandos de teclado. * [[Keyboard message]] Envía una cadena de texto cuando se presiona un botón. * [[Keyboard reprogram]] Abre una nueva ventana en el IDE de Arduino y reprograma el Leonardo con un simple programa de parpadeo. * [[Keyboard serial]] Lee un byte del puerto serie y devuelve una pulsación de tecla. * [[Keyboard mouse control]] Muestra los comandos del mouse y del teclado en un programa. === Ratón === * [[Button mouse control]] Control del movimiento del cursor con 5 botones. * [[Joystick mouse contol]] Controla el movimiento del cursor de una computadora con un Joystick cuando se presiona un botón. == Starterkit y BasicKit == Los tutoriales para los ejemplos del [https://www.arduino.cc/en/Tutorial/en/Main/ArduinoStarterKit StarterKit] están disponibles en el Libro de proyectos incluido en el kit, si compra un [https://www.arduino.cc/en/Tutorial/en/Main/ArduinoBasicKit BasicKit], podrá acceder a los proyectos en línea en [https://123d.circuits.io/shop/arduino Project Ignite]. == Arduino ISP == [https://www.arduino.cc/en/Tutorial/ArduinoISP Arduino ISP] convierte su Arduino en un programador en circuito para volver a programar los chips ATmega. Útil cuando necesite volver a cargar el gestor de arranque en un Arduino, [https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard si va de Arduino a un ATmega en una placa de prueba], o si está haciendo su [https://www.arduino.cc/en/Tutorial/en/Main/Standalone propio circuito compatible con Arduino en una placa de prueba]. == Referencias == [https://www.arduino.cc/en/Tutorial/BuiltInExamples Ejemplos incorporados] [[Category:Ejemplos]] 0dkvwqwemafwxi8t3tta2b803so5ft1 0 57 2070 1465 2018-07-17T21:15:12Z Kike GL 2 wikitext text/x-wiki Este wiki es editado por algunos entusiastas del [https://forum.arduino.cc/index.php?board=32.0 foro de Arduino en español]. * [[Usuario:AlexLPD|AlexLPD]] * [[Usuario:Noter|Noter]] * [[Usuario:Lucario448|Lucario448]] * [[Usuario:Jopapa|Jopapa]] * Surbyte * [[Usuario:Swift|Swift]] * [[Usuario:Tauro0221|Tauro0221]] * [[Usuario:Kike_GL|Kike_GL]] Pronto mas actualizaciones, gracias {{Nota|Si te interesa colaborar con este proyecto y eres por lo menos usuario '''Full Member''' solo tienes que crearte una cuenta en este Wiki (arriba derecha) y luego contactar con '''Kike_GL''' en el foro de Arduino en español, gracias.}} eab3qybqrmexl8aq57yav6c009whcrd 0 5 5067 5066 2019-10-13T13:32:29Z Kike GL 2 /* Sintaxis adicional */ wikitext text/x-wiki Los elementos del código Arduino (C ++). == Boceto == La estructura básica del lenguaje de programación de Arduino es bastante simple y se compone de al menos dos partes. Estas dos partes necesarias, o funciones, encierran bloques que contienen declaraciones, estamentos o instrucciones. Lo básico en cualquier [[boceto]] de Arduino. No puede faltar. * [[setup()]] * [[loop()]] == Estructura de control == Como su nombre lo indica te permite desviarte del flujo secuencial, según alguna condición o repetir un bloque mediante cualquiera de los bucles. * [[if... else]] - Condicional simple * [[Asignación condicional]] * [[switch... case]] - Condicional multiple * [[for]] - Bucle fijo * [[while]] - Bucle condicional anterior * [[do... while]] - Bucle condicional posterior * [[break]] - Detener condicional múltiple o bucle. * [[continue]] - Volver a evaluar condición en bucle. * [[goto]] - Salta hacia una etiqueta * [[return]] - Retorno == Sintaxis adicional == * [[include]] <nowiki>(#)</nowiki> * [[defined]] <nowiki>(#)</nowiki> * [[DEBUG]] * [[const]] * [[volatile]] == Operadores aritméticos == Son operadores básicos que permiten construir expresiones mas complejas. * [[asignacion]] <nowiki>(=)</nowiki> * [[suma]] <nowiki>(+)</nowiki> * [[resta]] <nowiki>(-)</nowiki> * [[multiplicación]] <nowiki>(*)</nowiki> * [[división]] <nowiki>(/)</nowiki> * [[modulo]] <nowiki>(%)</nowiki> == Operadores de comparación == Son los operadores usados para construir condiciones. * [[igualdad]] <nowiki>(==)</nowiki> * [[diferente]] <nowiki>(!=)</nowiki> * [[mayor]] <nowiki>(>)</nowiki> * [[mayor igual]] <nowiki>(>=)</nowiki> * [[menor]] <nowiki>(<)</nowiki> * [[menor igual]] <nowiki>(<=)</nowiki> == Operadores booleanos == Son operadores lógicos que se usan para unir condiciones de forma que existe una única respuesta. * [[not]] <nowiki>(!)</nowiki> * [[and]] <nowiki>(&&)</nowiki> * [[or]] <nowiki>(||)</nowiki> * [[xor]] <nowiki>(^)</nowiki> == Operadores bit a bit == Este tipo de operador te permite manipular un numero a nivel de sus bits. * [[not bit a bit]] <nowiki>(~)</nowiki> * [[and bit a bit]] <nowiki>(&)</nowiki> * [[or bit a bit]] <nowiki>(|)</nowiki> * [[xor bit a bit]] <nowiki>(^)</nowiki> * [[bitshift right]] <nowiki>(>>)</nowiki> * [[bitshift left]] <nowiki>(<<)</nowiki> == Operadores compuestos == Este tipo de operadores se usan para hacer operaciones sobre la misma variable. * [[incremento]] <nowiki>(++)</nowiki> * [[decremento]] <nowiki>(--)</nowiki> * [[suma compuesta]] <nowiki>(+=)</nowiki> * [[resta compuesta]] <nowiki>(-=)</nowiki> * [[multiplicacion compuesta]] <nowiki>(*=)</nowiki> * [[division compuesta]] <nowiki>(/=)</nowiki> * [[modulo compuesto]] <nowiki>(%=)</nowiki> == Operadores bit a bit compuestos == Este tipo de operadores se usan para hacer operaciones bit a bit sobre la misma variable. * [[or bit a bit compuesto]] <nowiki>(|=)</nowiki> * [[and bit a bit compuesto]] <nowiki>(&=)</nowiki> * [[bitshift right]] <nowiki>(>>=)</nowiki> * [[bitshift left]] <nowiki>(<<=)</nowiki> == Operadores ternarios == * [[Asignación condicional]] == Operadores de acceso a punteros == Para acceder directamente a bloques de memoria. * [[asterisco]] <nowiki>(*)</nowiki> * [[ampersan]] <nowiki>(&)</nowiki> == Otros == * [[Comentarios]] (//) * [[Palabras reservadas]] == Vea también == * [[Variables]] * [[Funciones]] [[Category:Referencias]] 0yztsg01v0zlvt8sbrsdkjz0m9e7avb 0 121 5277 4902 2020-03-16T17:18:04Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == La libreria [https://github.com/arduino-libraries/Ethernet Ethernet2.h] de Paul Stoffregen están diseñadas para funcionar con Arduino Ethernet Shield (Ethernet.h) o Arduino Ethernet Shield 2 y Leonardo Ethernet (Ethernet2.h). Esta librerias permiten que una placa Arduino se conecte a Internet. La placa puede servir como un '''servidor''' que acepta conexiones entrantes o un '''cliente''' que hace las conexiones salientes. La libreria admiten hasta cuatro conexiones simultáneas (entrantes o salientes o una combinación), gestiona el chip W5100 y W5500; todas las funciones son las mismas siendo sus códigos portables. {{Tip|Librería oficial, es decir que está preinstalada junto con la IDE de Arduino, no es necesario descargarla.}} == Placas aplicables == Actualmente (2018) se comercializan Ethernet Shield W5100 y Ethernet Shield W5500 compatibles con UNO, MEGA y Leonardo. Además disponen de un zócalo para una memoria MicroSD por si se quiere almacenar o recuperar datos de forma masiva. == Sintaxis == <pre> #include <SPI.h> #include <Ethernet.h> Ethernet.begin(mac,ip,gateway,subnet); </pre> == Parámetros == ;mac: ;ip: ;gateway: ;subnet: == Métodos == === Ethernet === La clase '''Ethernet''' inicializa la librería y la configuración de red. <pre> #include <SPI.h> #include <Ethernet.h> </pre> {| class="wikitable" |+Clase Ethernet |- ! Método !! Descripción |- | Ethernet.begin(mac,ip,dns,gateway,subred) || Inicializa la biblioteca de Ethernet y la configuración de red. |- | Ethernet.dnsServerIP() || |- | Ethernet.gatewayIP() || Retorna la dirección IP de la puerta de enlace para el dispositivo. |- | Ethernet.hardwareStatus() || le indica qué chip del controlador Ethernet WIZnet se detectó durante Ethernet.begin(), si lo hay. Esto se puede usar para solucionar problemas. Si no se detectó un controlador Ethernet, es probable que haya un problema de hardware. |- | Ethernet.init(pin) || Se usa para configurar el pin CS (selección de chip) para el chip del controlador Ethernet. La biblioteca Ethernet tiene un pin CS predeterminado, que generalmente es correcto, pero con algunos hardware Ethernet no estándar, es posible que necesite usar un pin CS diferente. |- | Ethernet.linkStatus() || Le dice si el enlace está activo. Link OFF podría indicar que el cable Ethernet está desconectado o defectuoso. Esta función solo está disponible cuando se utilizan los chips del controlador Ethernet W5200 y W5500. |- | Ethernet.localIP() || Obtiene la dirección IP del modulo Ethernet. Útil cuando la dirección se asigna automáticamente a través de DHCP. |- | Ethernet.MACAddress(mac) || Llena el búfer suministrado con la dirección MAC del dispositivo. |- | Ethernet.maintani() || Renovación del DHCP. Cuando se les asigna una dirección IP a través de DHCP, los dispositivos de Ethernet reciben un contrato de arrendamiento de la dirección por un período de tiempo. Con este metodo es posible solicitar la renovación del servidor DHCP. Dependiendo de la configuración del servidor, puede recibir la misma dirección, una nueva o ninguna. |- | Ethernet.setDnsServerIP(DNS) || Establezca la dirección IP del servidor DNS. No debe usarse con DHCP. |- | Ethernet.setGatewayIP(Port) || Establezca la dirección IP de la puerta de enlace de red. No debe usarse con DHCP. |- | Ethernet.setLocalIP(IP) || Establezca la dirección IP del dispositivo. No debe usarse con DHCP. |- | Ethernet.setMACAddress(mac) || Establece la dirección MAC. No debe usarse con DHCP. |- | Ethernet.setRetransmissionCount() || |- | Ethernet.setRetransmissionTimeout() || |} === Server === Es cuando Arduino actúa como servidor y responde alas ordenes de los clientes. La clase '''server''' crea servidores que pueden enviar y recibir datos a clientes conectados (programas que se ejecutan en otras computadoras o dispositivos). <pre> EthernetServer server = EthernetServer(puerto); </pre> {| class="wikitable" |+Clase Server |- ! Método !! Descripción |- | server.begin() || Le dice al servidor que comience a escuchar las conexiones entrantes. |- | server.available() || Obtiene un cliente que está conectado al servidor y tiene datos disponibles para leer. La conexión persiste cuando el objeto de cliente devuelto queda fuera de alcance; puede cerrarlo llamando al cliente.stop(). |- | server.accept() || La función tradicional server.available() solo le informaría de un nuevo cliente después de enviar los datos, lo que hace que algunos protocolos como FTP sean imposibles de implementar correctamente. |- | server.write() || Escribir datos a todos los clientes conectados a un servidor. Estos datos se envían como un byte o serie de bytes. |- | server.print(dato, base) || Imprime datos en todos los clientes conectados a un servidor. Imprime los números como una secuencia de dígitos, cada uno con un carácter ASCII (por ejemplo, el número 123 se envía como los tres caracteres '1', '2', '3'). |- | server.println(dato, base) || Imprime datos, seguidos de una nueva línea, a todos los clientes conectados a un servidor. Imprime los números como una secuencia de dígitos, cada uno con un carácter ASCII (por ejemplo, el número 123 se envía como los tres caracteres '1', '2', '3'). |} === Client === Es el modo por el cual el Arduino pide información a un servidor. La clase de '''client''' crea clientes que pueden conectarse a servidores, enviar y recibir datos. <pre> EthernetClient client; </pre> {| class="wikitable" |+Clase Cliente |- ! Método !! Descripción |- | client.connect() || Connects to a specified IP address and port. The return value indicates success or failure. Also supports DNS lookups when using a domain name. |- | client.connected() || Si el cliente está conectado o no. Tenga en cuenta que un cliente se considera conectado si la conexión se ha cerrado pero todavía hay datos no leídos. |- | client.write(dato) || Escriba datos en el servidor al que está conectado el cliente. Estos datos se envían como un byte o serie de bytes. |- | client.available() || Devuelve el número de bytes disponibles para leer (es decir, la cantidad de datos que el servidor al que está conectado ha escrito al cliente). |- | client.read() || Lea el siguiente byte recibido del servidor al que está conectado el cliente (después de la última llamada para leer ()). |- | client.flush() || Espera hasta que se hayan enviado todos los caracteres salientes en el búfer. |- | client.print(dato, base) || Imprime datos en el servidor al que está conectado un cliente. Imprime los números como una secuencia de dígitos, cada uno con un carácter ASCII (por ejemplo, el número 123 se envía como los tres caracteres '1', '2', '3'). |- | clinet.println(dato, base) || Imprime datos, seguidos de un retorno de carro y una nueva línea, al servidor al que está conectado un cliente. Imprime los números como una secuencia de dígitos, cada uno con un carácter ASCII (por ejemplo, el número 123 se envía como los tres caracteres '1', '2', '3'). |- | client.stop() || Desconecta el cliente |} === UDP === El protocolo UDP (Protocolo de Datagrama de Usuario), es ligero por lo que no tiene la parte de seguridad. No existe un control del envio de paquetes, es decir no se preocupa de el estado como lleguen los datos. Su puerto esta abierto a cualquier dispositivo. Se usa para transmitir datos a alta velocidad como en resolución de DNS, streaming, VoIP y juegos online. La clase EthernetUDP permite enviar y recibir mensajes UDP. <pre> #include <EthernetUdp.h> EthernetUDP Udp; </pre> {| class="wikitable" |+Clase EthernetUDP |- ! Método !! Descripción |- | Udp.begin(puerto) || Inicializa la biblioteca de ethernet UDP y la configuración de red. |- | Udp.status() || |- | Udp.hardwareStatus() || |- | Udp.status() || |- | Udp.remoteIP() || |- | Udp.remotePort() || |- | Udp.remoteIP() || |- | Udp.getSocketNumber() || |- | Udp.localIP() || |- | Udp.localPort() || |- | Udp.MACAddress() || |- | Udp.setConnectionTimeout() || |- | Udp.setRetransmissionCount() || |- | Udp.setLocalIP() || |- | Udp.setSubnetMask() || |- | Udp.setGatewayIP() || |- | Udp.setDnsServerIP() || |- | Udp.stop() || |} == Advertencias == * Arduino se comunica con el modulo (shield) usando el bus [[SPI]] con los pines digitales 11, 12 y 13 en el [[UNO]] y los pines 50, 51 y 52 en el [[MEGA]]. En ambas placas, el pin 10 se usa como SS. * En el [[MEGA]] el pin de hardware SS (53) no se usa para seleccionar el W5100, pero debe mantenerse como salida o la interfaz [[SPI]] no funcionará. == Ejemplos == * Al modulo (shield) se le debe asignar una dirección MAC y una dirección IP fija usando la función '''Ethernet.begin()'''. Una dirección MAC es un identificador global único para un dispositivo en particular. Los modulo (shield) Ethernet actuales vienen con una pegatina que indica la dirección MAC que debe usar con ellos. * Las direcciones IP válidas dependen de la configuración de su red. * Es posible usar DHCP para asignar dinámicamente una IP al modulo (shield). * Opcionalmente, también puede especificar una puerta de enlace de red y una subred. === Client === * [[WebClient|Web Client]] Hace una petición HTTP al servidor. * [[WebClientRepeating|Web Client Repeating]] Hace peticiónes HTTP repetitiva al servidor. * [[WebClientData|Web Client Data]] Envia un dato a un servidor Xampp. === Server === * [[WebServer|Web Server]] Alojar (host) una página HTML simple que muestra valores de sensores analógicos. * [[ChatServer|Chat Server]] Configura un chat server. === Otros === * [[UDPSendReceiveString|UDP Send Receive String]] Envía y recive texto via UDP. * UdpNtpClient: Query a Network Time Protocol (NTP) server using UDP. * DnsWebClient: DNS and DHCP-based Web client. * DhcpChatServer: A simple DHCP Chat Server * DhcpAddressPrinter: Get an IP address via DHCP and print it out * TelnetClient: A simple Telnet client == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info All libraries] * [http://www.arduino.cc/en/Reference/Ethernet Ethernet] - Arduino * [https://naylampmechatronics.com/blog/27_Tutorial-Ethernet-Shield-y-Arduino.html Tutorial Ethernet] - Naylamp * [https://www.youtube.com/watch?v=idHOUiCzIRA Arduino Ethernet] - Rincon Ingenierial * [https://www.youtube.com/watch?v=MuNi8edyQVw Conexion de Arduino a internet] - El profe Garcia * [http://diymakers.es/crear-servidor-web-con-arduino/ Crear servidor web con Arduino] - Diy Makers [[Category:Librerias]] [[Category:Libreria Ethernet]] 2hq7om1q6kbcpvos4terz5u1yumdpph 0 200 4801 4800 2019-07-18T17:12:29Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == La macro '''F()''' permite guardar la cadena a mostrar en monitor serie con [[Serial.print()]] o [[Serial.println()]] en la memoria [[flash]] en lugar de la [[SRAM]]. {{Nota|Si en el [[boceto]] tienes un montón de cosas que mostrar en el monitor serie, puedes llenar fácilmente la memoria [[SRAM]], por eso es aconsejable usar esta macro para guardar esos textos en la memoria [[flash]].}} {{Nota|Cualquier clase que "herede" de Print o [[Stream]] (ej.: [[Serial]]), tendrá acceso a las funciones '''print'''; las cuales siempre serán compatibles con esta macrofunción.}} {{Nota|Es posible crear una función o método personalizado que acepte esta macro, el tipo de dato es '''const __FlashStringHelper*''' (puntero); sin embargo cabe recordar que la memoria [[flash]] es de sólo lectura para efectos de ejecución, las modificaciones sólo son posibles si los datos se copian a [[SRAM]] de antemano (mediante variables o vectores/matrices).}} == Sintaxis == <pre> Serial.print(F("texto a mostrar")); </pre> == Comentarios == Nada. == Advertencias == * '''F()''' al ser una macrofunción, solo se ejecuta en tiempo de compilación. Esto quiere decir que de parámetros se aceptan únicamente literales (entrecomillados) y cadenas de caracteres declarados como '''[[const]] [[char]]*'''; nada de vectores/matrices [[string]], ni siquiera objetos [[String]]. En resumen, '''solamente texto invariable se acepta'''. == Ejemplos == <syntaxhighlight lang="c++"> Serial.println(F("Escribe algo en el monitor serie que se almacena en FLASH")); </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias externas == * [https://programarfacil.com/blog/arduino-blog/conversion-de-numeros-a-cadenas-en-arduino/ Converison de numeros a cadenas] - Luis del Valle [[Category:Funciones]] [[Category:Serial]] aybtpxh4t02jsfgbabuc67jx3gusozc 0 452 3955 3954 2019-05-17T22:33:02Z Kike GL 2 /* Puedo usar un IDE diferente ? */ wikitext text/x-wiki == Qué es Arduino ? == Me alegra que hayas preguntado, tenemos una gran página de introducción en Arduino, haz [http://www.arduino.cc/en/Guide/Introduction clic aquí] para leerla. == Y que hay de Genuino ? == Buena pregunta, aprenda todo sobre [http://www.arduino.cc/en/Main/GenuinoBrand Genuino] y dónde está disponible esta marca aquí. == Qué quieres decir con hardware de código abierto ? == El hardware de código abierto comparte gran parte de los principios y el enfoque del software libre y de código abierto. En particular, creemos que las personas deberían poder estudiar nuestro hardware para comprender cómo funciona, realizar cambios y compartir esos cambios. Para facilitar esto, lanzamos todos los archivos de diseño original (Eagle CAD) para el hardware Arduino. Estos archivos están autorizados bajo una licencia Creative Commons Attribution Share-Alike, que permite trabajos derivados tanto personales como comerciales, siempre que acrediten a Arduino y lancen sus diseños bajo la misma licencia. El software Arduino también es de código abierto. El código fuente para el entorno Java se publica bajo la GPL y las bibliotecas del microcontrolador C / C ++ están bajo la LGPL. == Cómo puedo obtener una placa Arduino ? == Puede comprar una placa Arduino en la [http://store.arduino.cc/ tienda oficial] en línea o en uno de los distribuidores que figuran en [http://www.arduino.cc/en/Main/Buy esta página]. Si prefieres construir el tuyo, consulta la [http://www.arduino.cc/en/Main/ArduinoBoardSerialSingleSided3 placa de serie de un solo lado de Arduino], que se puede grabar y ensamblar fácilmente. == Cuáles son las placas oficiales de Arduino ? == Las placas oficiales de Arduino son los que figuran en la [http://www.arduino.cc/en/Main/Products página del productos]. Estos son placas cuyos fabricante trabajan con el equipo de Arduino para garantizar una buena experiencia de usuario, compatibilidad con el [[IDE]] de Arduino y un producto de calidad. A cambio de su estatus como juntas oficiales, los fabricantes pagan una tarifa de licencia al equipo de Arduino para apoyar el desarrollo del proyecto. En general, restringimos el uso del nombre "Arduino" para las placas oficiales. Si encuentra un producto con un nombre diferente pero descrito como "compatible con Arduino", probablemente no sea una placa oficial y no financie el trabajo continuo en el proyecto. * Lea sobre Clones, Derivados y Falsificaciones por Massimo Banzi ([http://blog.arduino.cc/2013/07/10/send-in-the-clones/ Blog]) * Aprenda sobre cómo detectar una falsificación ([http://arduino.cc/en/Products/Counterfeit Sitio web]) == Puedo usar el logotipo de Arduino para identificar contenido no comercial ? == Si estás creando tutoriales, gestionando una comunidad local de usuarios de Arduino, abriendo una página enfocada en Arduino en línea (es decir, redes sociales), puede usar el [http://www.arduino.cc/en/Trademark/CommunityLogo logotipo de la comunidad de Arduino]. Esto permitirá a las personas identificar mejor lo que viene directamente de nosotros y lo que viene de la comunidad. == Quiero diseñar mi propia placa. qué debo hacer ? == Los diseños de referencia para las placas Arduino están disponibles en las páginas específicas de sus productos. Están autorizados bajo una licencia Creative Commons Attribution Share-Alike, por lo que puede usarlos y adaptarlos a sus propias necesidades sin pedir permiso o pagar una tarifa. Si desea hacer algo de interés para la comunidad, le recomendamos que exponga sus ideas en el [http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?board=hwdev foro de desarrollo de hardware] donde los usuarios potenciales puedan ofrecer sugerencias. == Cómo debo llamar a mis placas ? == Si estás haciendo tu propia tabla, crea tu propio nombre! Esto permitirá que las personas lo identifiquen con sus productos y lo ayudarán a construir una marca. Sea creativo: intente sugerir para qué usaría la pizarra, o enfatizar el factor de forma, o simplemente elija una palabra aleatoria que suene bien. "Arduino" es una marca comercial de Arduino LLC y no debe utilizarse para variantes no oficiales. Si está interesado en que su diseño esté incluido en la línea oficial de productos Arduino, consulte la sección Así que desea hacer un documento de Arduino y póngase en contacto con el equipo de Arduino. Si bien los productos no oficiales no deberían tener "Arduino" en su nombre, está bien describir su producto en relación con el proyecto y la plataforma Arduino. Aquí hay algunas pautas que explican qué usos consideramos razonables. === No es correcto === * Arduino Xxxxxx * Xxxxxx Arduino * Compatible con Arduino Xxxxxx: use "Xxxxxx (compatible con Arduino)" === Es correcto === * Xxxxxx para Arduino: productos que funcionan con placas oficiales Arduino (por ejemplo, modulos, componentes o kits) * Xxxxxx (compatible con Arduino): variaciones y clones que son compatibles con software y hardware. Tenga en cuenta que si bien no intentamos restringir los usos del sufijo '''duino''', su uso hace que los italianos en el equipo se estremezcan (aparentemente suena terrible); es posible que desee evitarlo. (También es una marca registrada por una empresa húngara). == Puedo construir un producto comercial basado en Arduino ? == Sí, con las siguientes condiciones: * La incorporación física de una placa Arduino dentro de un producto comercial no requiere que usted divulgue o abra cualquier fuente de información sobre su diseño. * Para obtener el diseño de un producto comercial de los archivos Eagle para una placa Arduino, debe liberar los archivos modificados bajo la misma licencia Creative Commons Attribution Share-Alike. Usted puede fabricar y vender el producto resultante. * El uso del núcleo y las bibliotecas de Arduino para el firmware de un producto comercial no requiere que libere el código fuente del firmware. Sin embargo, la LGPL le exige que ponga a disposición archivos de objetos que permitan volver a vincular el firmware con versiones actualizadas del núcleo y las bibliotecas de Arduino. Cualquier modificación al núcleo y las librerias debe publicarse bajo la LGPL. * El código fuente para el entorno Arduino está cubierto por la GPL, que requiere que cualquier modificación sea de código abierto bajo la misma licencia. No impide la venta de software derivado o su inclusión en productos comerciales. En todos los casos, los requisitos exactos están determinados por la licencia correspondiente. Además, consulte la pregunta anterior para obtener información sobre el uso del nombre "Arduino". == Cómo puedo ejecutar el [[IDE]] de Arduino bajo Linux ? == Consulte las instrucciones para [http://www.arduino.cc/playground/Linux/Ubuntu Ubuntu Linux], para [http://www.arduino.cc/playground/Linux/Debian Debian Linux], para [http://www.arduino.cc/playground/Linux/Gentoo Gentoo Linux], para [http://www.arduino.cc/playground/Learning/Linux Linux] o para [http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1141345598 Linux en PPC]. Este [http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1129025529 hilo] del foro Arduino tiene más información. O bien, puede usar Arduino desde la [http://www.arduino.cc/playground/Learning/CommandLine línea de comandos] sin tener que instalar Java. == Puedo programar una placa Arduino en C ? == De hecho, ya lo haces en el [[IDE]]. El lenguaje Arduino es simplemente un conjunto de funciones C/C++ que se pueden llamar desde su código. Su [[boceto]] sufre cambios menores (por ejemplo, generación automática de prototipo de funciones) y luego se pasa directamente a un compilador C/C++ ([http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_cplusplus avr-g ++]). Todas las construcciones estándar de C y C++ compatibles con avr-g ++ deberían funcionar en Arduino. Para más detalles, vea la página sobre el proceso de [http://www.arduino.cc/en/Hacking/BuildProcess construcción de Arduino]. == Puedo usar un [[IDE]] diferente ? == Es posible compilar programas para Arduino usando otras herramientas de compilación (por ejemplo, Makefiles y / o AVR Studio). Tendrá que configurarlos para vincularlos con los archivos apropiados en las librerias principales de Arduino. Vea la descripción del [http://code.google.com/p/arduino/wiki/BuildProcess proceso de construcción] de Arduino. == Puedo usar el [[IDE]] Arduino con otras placas AVR ? == Sí, aunque puede requerir algunas modificaciones a las librerias centrales de Arduino. == Dónde está la sección de solución de problemas ? == Estas preguntas se han trasladado a la sección de [http://www.arduino.cc/en/Guide/Troubleshooting solución de problemas] de la guía Arduino. == Existe una Política de Privacidad sobre mis datos como usuario registrado ? == Sí, revisa nuestra página de [http://arduino.cc/en/Main/PrivacyPolicy Política de Privacidad]. Allí verá cómo manejamos la información de los usuarios registrados y nuestras políticas de no divulgación. == Referencias == [[Category:Arduino]] k1me8y3iqj4view67cl0cyx03naovs5 0 386 4932 4437 2019-09-21T14:31:30Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Una field Programmable Gate Array (FPGA) o matriz de puertas programables es un dispositivo electronico programable que contiene bloques de lógica cuya interconexión y funcionalidad puede ser configurada en el momento mediante un lenguaje de descripción especializado. La lógica programable puede reproducir desde funciones tan sencillas como las llevadas a cabo por una puerta lógica o un sistema combinacional hasta complejos sistemas en un chip. Las FPGA se usan en aplicaciones similares a los ASIC sin embargo son más lentas, tienen un mayor consumo de energía y no pueden abarcar sistemas tan complejos como ellos. A pesar de esto, las FPGA tienen las ventajas de ser reprogramables (lo que añade una enorme flexibilidad al diseño hardware), sus costos de desarrollo y adquisición son mucho menores para pequeñas cantidades de dispositivos y el tiempo de desarrollo es también menor. Ciertos fabricantes cuentan con FPGA que sólo se pueden programar una vez, por lo que sus ventajas e inconvenientes se encuentran a medio camino entre los ASIC y las FPGA re Históricamente las FPGA surgen como una evolución de los conceptos desarrollados en las PAL y los CPLD. {{Nota|Es un chip en blanco que contiene los tres componentes basicos: puertas logicas (AND, OR, XOR, NOT), biestables (R, S, T, D, K) y cables.}} == Historia == Las '''FPGA''' fueron inventadas en el año 1984 por Ross Freeman y Bernard Vonderschmitt, cofundadores de Xilinx y surgen como una evolución de los CPLD (Complex Programmable Logic Device). Tanto los CPLD como las '''FPGA''' contienen un gran número de elementos lógicos programables. Si medimos la densidad de los elementos lógicos programables en puertas lógicas equivalentes (número de puertas NAND equivalentes que podríamos programar en un dispositivo) podríamos decir que en un CPLD hallaríamos del orden de decenas de miles de puertas lógicas equivalentes y en una FPGA del orden de cientos de miles hasta millones de ellas. Aparte de las diferencias en densidad entre ambos tipos de dispositivos, la diferencia fundamental entre las FPGA y los CPLD es su arquitectura. La arquitectura de los CPLD es más rígida y consiste en una o más sumas de productos programables cuyos resultados van a parar a un número reducido de biestables síncronos (también denominados flip-flops). La arquitectura de las FPGA, por otro lado, se basa en un gran número de pequeños bloques utilizados para reproducir sencillas operaciones lógicas, que cuentan a su vez con biestables síncronos. La enorme libertad disponible en la interconexión de dichos bloques confiere a las '''FPGA''' una gran flexibilidad. Otra diferencia importante entre FPGA y CPLD es que en la mayoría de las '''FPGA''' se pueden encontrar funciones de alto nivel (como sumadores y multiplicadores) embebidas en la propia matriz de interconexiones, así como bloques de memoria. Las '''FPGA''' son el resultado de la convergencia de dos tecnologías diferentes, los [[PLC]] y los circuitos integrados de aplicación específica (ASIC). La historia de los [[PLC]] comenzó con los primeros dispositivos PROM (memoria programable de solo lectura) y se les añadió versatilidad con los PAL (matriz lógica programable) que permitieron un mayor número de entradas y la inclusión de registros. Esos dispositivos han continuado creciendo en tamaño y potencia. Mientras, los ASIC siempre han sido potentes dispositivos, pero su uso ha requerido tradicionalmente una considerable inversión tanto de tiempo como de dinero. Intentos de reducir esta carga han provenido de la modularización de los elementos de los circuitos, como los ASIC basados en celdas, y de la estandarización de las máscaras, tal como Ferranti fue pionero con la ULA (Uncommitted Logic Array). El paso final era combinar las dos estrategias con un mecanismo de interconexión que pudiese programarse utilizando fusibles, antifusibles o celdas RAM y celdas ROM, como los innovadores dispositivos Xilinx de mediados de los 80. Los circuitos resultantes son similares en capacidad y aplicaciones a los PLD más grandes, aunque hay diferencias puntuales que delatan antepasados diferentes. Además de en computación reconfigurable, las '''FPGA''' se usan en controladores, codificadores/decodificadores y en el prototipado de circuitos VLSI y microprocesadores a medida. == Características == * Hardware libre igual que software (Existen repositorios compartidos) * Fácil de compartir (basta compartir el archivo de configuracion de la FPGA) * Fácil de reproducir (clonar) * Fácil de diseñar == Programacion == En la FPGA no se realiza programación tal cual como se realiza en otros dispositivos como DSP, CPLD o microcontroladores. La FPGA tiene celdas que se configuran con una función específica ya sea como memoria (FLIP-FLOP tipo D), como multiplexor o con una función lógica tipo AND, OR, XOR. La labor del programador es describir el hardware que tendrá la FPGA. Por consiguiente, la tarea del programador es definir la función lógica que realizará cada uno de los CLB, seleccionar el modo de trabajo de cada IOB e interconectarlos. El diseñador cuenta con la ayuda de entornos de desarrollo especializados en el diseño de sistemas a implementarse en una FPGA. Un diseño puede ser capturado ya sea como esquemático, o haciendo uso de un lenguaje de programación especial. Estos lenguajes de programación especiales son conocidos como HDL o lenguajes de descripción de hardware. Los HDL más utilizados son: * VHDL * Verilog * ABEL En un intento de reducir la complejidad y el tiempo de desarrollo en fases de prototipaje rápido, y para validar un diseño en HDL, existen varias propuestas y niveles de abstracción del diseño. Los niveles de abstracción superior son los funcionales y los niveles de abstracción inferior son los de diseño al nivel de componentes hardware básicos. Entre otras, National Instruments LabVIEW FPGA propone un acercamiento de programación gráfica de alto nivel. == Fabricantes == El primer fabricante de estos dispositivos fue Xilinx y estos dispositivos se mantienen como uno de los más populares en compañías y grupos de investigación. Otros vendedores en este mercado son: Atmel, Altera, AMD, Laticce y Motorola. == FPGA Libres == * Clifford Wolf con ingeniería inversa logro hacer en Verilog todo los necesario para obtener el bitstring para enviar a la Lattice ICE 40 * Jesús Arroyo desarrollo APIO y ICEstudio un IDE libre == Vea también == * [[PLC]] * [[PIC]] * [[AVR]] * [[SCADA]] == Referencia == * [https://www.youtube.com/watch?v=XWC1B7UKv98&t=566s FPGA libres] - Juan Gonzalez (Obijuan) * [https://www.youtube.com/watch?v=K8bM14-R9Ts Buenas tiempos para las FPGA] - Sergio Cuenca [[Category:Placas]] 9so8a664ze6ksg37xgd7jqv5lvic6f8 0 147 3698 3697 2019-05-06T21:48:30Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Este ejemplo demuestra el uso de la función [[analogWrite()]] o PWM en el desvanecimiento de un LED. [[analogWrite()]] usa modulación por ancho de pulso (PWM), activa y desactiva un pin digital muy rápidamente con una relación diferente entre encendido y apagado, para crear un efecto de desvanecimiento. == Circuito == Debes poner un LED con su respectiva resistencia de 220 ohms entre un pin digital PWM y GND o +5V como quieras. Respeta la polaridad del LED. == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> const byte led = 9 ; //LED con PWM int brillo = 0 ; //Brillo del LED const byte paso = 5; //cuántos puntos desvanecen el LED void setup () { pinMode(led, OUTPUT); } void loop ( ) { analogWrite(led, brillo); brillo = brillo + paso; //Invierte direccion if (brillo<=0 || brillo>=255) { paso = -paso; } delay(30); } </syntaxhighlight> == Comentarios == * Brillo debe estar este 0~255 que es el rango PWM. * El LED debe estar en un pin digital tipo PWM. En Arduino [[UNO]] puede ser: 3, 5, 6, 9, 10 y 11. == Vea también == <categorytree mode=all>Basicos</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/Fade Ejemplos incluidos] [[Category:Basicos]] 4as4xyp31b1tj5hw4stz6m6ktyimf8w 0 228 3712 995 2019-05-06T21:56:21Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Analogico</categorytree> == Referencias == [[Category:Analogico]] 2i9mmc2o0iyv8al1yd55kjmy3kjkj6x 0 393 4270 4269 2019-06-11T23:19:01Z Kike GL 2 /* Referencias */ wikitext text/x-wiki Arduino tiene algunas funciones que manejan directamente los temporizadores y tienen usos diversos. Pero recuerda que Arduino no tiene un temporizador permanente como si es el modulo RTC asi que no puede saber la fecha y hora. Todos sus temporizadores se '''resetean''' al desconectar la energía. == Tiempos == En Arduino tenemos algunas funciones que '''detienen la ejecución del boceto'''. {{Nota|Tenga mucho cuidado ya que durante ese tiempo el uC no hace nada mas que esterar se cumpla el retardo.}} * [[delay()]] Pausa el programa por la cantidad de milisegundos especificado como parámetro. No devuelve nada. * [[delayMicroseconds()]] Pausa el programa por la cantidad de mcrosegundos especificado como parámetro. No devuelve nada. {{Nota|Si bien es fácil crear un LED parpadeante con la funcion [[delay()]] y muchos bocetos lo usan, también es usado como anti [[Rebote]] de pulsadores, el uso de [[delay()]] en un boceto tiene inconvenientes importantes. Ninguna otra lectura o manipulacion de de puerto, cálculos matemáticos puede ejecutarse durante la función de retardo, por lo que, en efecto, detiene la mayoría de otras actividades. Para obtener enfoques alternativos para controlar el tiempo consulte:}} * [[millis()]] - Devuelve la cantidad de milisegundos desde que la placa Arduino comenzó a ejecutar el programa actual. * [[micros()]] - Devuelve la cantidad de microsegundos desde que la placa Arduino comenzó a ejecutar el programa actual. == Fecha y hora == Los temporizadores internos de Arduino son de corto plazo. Pero que hacer cuando requerimos por ejemplo poner fecha y hora en nuestro tabulado de datos de sensores (datalogger) para un análisis posterior ? Estas funciones están disponibles si añades la librería estándar de Arduino [https://github.com/PaulStoffregen/Time/blob/master/TimeLib.h TimeLib.h]. Lo primero que hace la librería '''TimeLib.h''' es definir un tipo especial de variable que llamamos [[time_t]] de 32 bits, que es la base de todo, porque almacena valores de tiempo en un formato especial calculado como el número de segundos transcurridos desde el 1-ENE-1970, llamada fecha Unix. {| class="wikitable" |+Funciones disponibles con TimeLib.h |- ! Funciones !! Descripción !! rango |- | [[millis()]] || Milisegundos || 0~999 |- | second() || Segundos || 0~59 |- | minute() || Minutos || 0~59 |- | hour() || Hora || 0~23 |- | day() || Numero de dia || 1~31 |- | weekday() || Dia de la semana || 1~7 (1=domingo) |- | dayStr(weekday()) || Nombre de dia || Saturday, Sunday |- | dayShortStr(weekday()) || Nombre corto del dia || Mon, Sat, Sun |- | month() || Numero de mes || 1~12 |- | monthStr(month()) || Nombre del mes || July, Dicember |- | monthShort(month()) || Nombre corto del mes || Jul, Dic |- | year() || Año || 4 digitos |- | hourFormat12() || Pone en formato 12 horas || 0~11 |- | isAM() || AM || Verdadero por la mañana |- | isPM() || PM || Verdadero por la tarde |- | now() || Tiempos Unix || Segundos desde 1-ENE-1970 |} {{Nota|Fantástico ya tenemos creada nuestra variable del tipo '''time_h''' con la hora actual según nuestro Arduino... pero espera no que Arduino no sabia la fecha ni hora ? exacto lo que acabas de obtener es un porquería y hay que arreglar el Arduino.}} == Sincronizar reloj Arduino == La función [[setTime()]] nos permite decirle al Arduino en que día y hora estamos y que a partir de alli mantenga '''sincronizado''' adecuadamente esa fecha hasta su próximo reseteo. <pre> setTime(ss); //Numero de segundos desde 1-ENE-1970 setTime(hh,mm,ss,dia,mes,año); //hora, minuto,segundo dia, mes, año </pre> == Otros métodos de la libreria == <pre> adjustTime(ajuste); //Ajusta fecha y hora añadiendo un ajuste setSyncProvider(getTimeFuncion); //Configurar proveedor externo setSyncInterval(intervalo); //Indicar el intervalo de re-sincronizacion timeStatus(); //Informa si el reloj fue sincronizado recientemente. </pre> Las posibles respuestas de timeStatus() son: ;timeNotSet:La fecha y hora nunca fue sincronizada ;timeNeedsSync:La fecha y hora fue isincronizada pero no se completo ;timeSet:Todo esta sincronizado == Matemática con fechas == Si requieres trabajar con matematica de fechas, es decir que requeriras crear fechas y no presisamente sincronizar el reloj de Arduino, debes usar un tipo de dato matriz llamado '''tmElements_t''' que nos permite asignar cada uno de los elementos de la fecha-hora por separado como si se tratara de un conjunto de métodos asi: <pre> tmElements_t tx; tx.Second = Segundos; (0~59) tx.Minute = Minuto; (0~59) tx.Hour = Hora; (0~23) tx.Day = Dia; (1~31) tx.Month = Mes; (1~12) tx.Year = Año; (0~99) diferencia desde 1970. </pre> Luego puedes usar la función [[makeTime()]] que lo que hace es pasar una variable del tipo '''tmElements_t''' a una variable del tipo '''time_t''' <pre> time_t tiempo = makeTime(elementos); </pre> Donde tiempo es del tipo '''time_t''' y elementos es del tipo '''tmElements_t'''. Asi mismo si tenemos una variable tipo '''time_t''' también la podemos descomponer en una variable tipo '''tmElements_t''' con breakTime(). <pre> tmElements_t elementos; breakTime(tiempo, elementos); </pre> == Ejemplo 1 == Fijamos una fecha y hora y mostramos cada segundo. <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(115200); setTime(8,0,0,14,7,2018); //14-JUL-2018 08:00:00 } void loop(){ time_t t = now(); if (hour(t) < 10){ Serial.print("0"); } Serial.print(hour(t)); Serial.print(":"); if (minute(t) < 10){ Serial.print("0"); } Serial.print(minute(t)); Serial.print(":"); if (second(t) < 10){ Serial.print("0"); } Serial.println(second(t)); delay(1000); } </syntaxhighlight> == Ejemplo 2 == Fijamos una fecha y hora y mostramos cada segundo. Nota que no es necesario usar now(), simplemente consultamos la '''funciones vacias''' directamente <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup() { Serial.begin(115200); while (!Serial); //Esperar hasta que monitor serie esta listo setTime(8,30,0,14,7,2019); if (timeStatus()!= timeSet){ Serial.println("No se logro sincronizar"); }else{ Serial.println("Tenemos el reloj sincronizado"); } } void loop(){ if (timeStatus() == timeSet) { digitalClockDisplay(); }else{ Serial.println("El reloj no fue sincronizado."); delay(3000); } delay(1000); } void digitalClockDisplay(){ printDig(hour()); Serial.print(":"); printDig(minute()); Serial.print(":"); printDig(second()); Serial.print(" "); printDig(month()); Serial.print("-"); printDig(day()); Serial.print("-"); Serial.println(year()); } void printDig(int digits){ if(digits < 10) Serial.print('0'); Serial.print(digits); } </syntaxhighlight> == Ejemplo 3 == Calcular la diferencia entre dos fechas. Por ejemplo del 6-NOV al 13-NOV del 2018. Respuesta: 0 años, 0 meses, 7 dias, 20 horas, 28 minutos, 0 segundos. <syntaxhighlight lang="c++"> #include <TimeLib.h> time_t t0,t1,dif; void setup(){ Serial.begin(115200); t0 = ponFecha(2018, 11, 6, 20, 17, 0); //6-NOV-2018 20:17:00 printFecha(t0); t1 = ponFecha(2018, 11, 13, 16, 45, 0); //13-NOV-2018 16:45:00 printFecha(t1); Serial.println("--------------------------------------------------"); dif = t1 - t0; Serial.print(String(year(dif)-1970) + " años, " + String(month(dif)-1) + " meses, "); Serial.print(String(day(dif)) + " dias, " + String(hour(dif)) + " horas "); Serial.println(String(minute(dif)) + " minutos, " + String(second(dif)) + " segundos."); Serial.println("---------------------------------------------------"); } time_t ponFecha(int y, int m, int d, int hh, int mm, int ss){ tmElements_t f; f.Second = ss; f.Minute = mm; f.Hour = hh; f.Day = d; f.Month = m; f.Year = y - 1970 ; return makeTime(f); //Crea tiempo Unix } void printFecha(time_t t){ if (day(t) < 10){ Serial.print("0"); } Serial.print(day(t)); //dia Serial.print("-"); if (month(t) < 10){ Serial.print("0"); } Serial.print(month(t)); //mes Serial.print("-"); Serial.print(year(t)); //año Serial.print(" "); if (hour(t) < 10){ Serial.print("0"); } Serial.print(hour(t)); //hora Serial.print(":"); if (minute(t) < 10){ Serial.print("0"); } Serial.print(minute(t)); //minutos Serial.print(":"); if (second(t) < 10){ Serial.print("0"); } Serial.println(second(t)); //segundos } void loop(){ //Nada } </syntaxhighlight> {{Nota|Pon atención a la funciónes de usuario: '''ponFecha() y '''printFecha()''' que son muy interesantes.}} == Ejemplo 4 == Dada una fecha 2019-7-14 8:30:00 sumar una hora y media (5400 segundos) <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(115200); tmElements_t tx; tx.Second = 0; tx.Minute = 30; tx.Hour = 8; tx.Day = 14; tx.Month = 7; tx.Year = 49; //2019-1970 muestra(tx); //Funcion muesra fecha y hora time_t ta = makeTime(tx); ta += 5400; //Sumar 1.5 hrs tmElements_t tz; breakTime(ta, tz); muestra(tz); //Funcion muesra fecha y hora } void loop() { //Nada } void muestra(tmElements_t ty){ Serial.print(ty.Year + 1970); Serial.print("-"); if (ty.Month<10){ Serial.print('0'); } Serial.print(ty.Month); Serial.print("-"); if (ty.Day<10){ Serial.print('0'); } Serial.print(ty.Day); Serial.print(" "); if (ty.Hour<10){ Serial.print('0'); } Serial.print(ty.Hour); Serial.print(":"); if (ty.Minute<10){ Serial.print('0'); } Serial.print(ty.Minute); Serial.print(":"); if (ty.Second<10){ Serial.print('0'); } Serial.println(ty.Second); } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones tiempo</categorytree> Libreria TimeLib.h * [[time_t]] * [[tmElements_t]] * [[setTime()]] * [[adjustTime()]] * [[timeStatus()]] * [[makeTime()]] * [[breakTime]] * [[NTP]] Libreia RTClib.h * [[now()]] * [[DateTime]] * [[TimeSpan()]] == Referencias externas == * [https://www.prometec.net/time-arduino/ Libreria Time en Arduino] [[Category:Funciones tiempo]] 5z5k4kxvj4xqtp3417c7u4js8mk4c86 0 447 4595 4587 2019-07-03T19:17:34Z Kike GL 2 /* Sintaxis */ wikitext text/x-wiki == Descripción == Obtiene el número de bytes disponibles para leer en el archivo (antes de llegar al final de este). == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.available(); </pre> == Parámetros == Nada. == Retorno == La cantidad de bytes/caracteres disponibles para lectura ([[int]]). == Comentarios == Si hay más de 32 KB para leer, esta función siempre retornará 32767 hasta que ocurra lo contrario. Por lo tanto, esta no es la forma más certera de hacerlo si se necesitara de un valor exacto; y mucho menos para determinar el tamaño de archivo. En ese caso, el cálculo más adecuado sería: <syntaxhighlight lang="c++"> unsigned long bytesRestantes = archivo.size() - archivo.position(); </syntaxhighlight> == Ejemplo == Alternativa al ejemplo en [[File.read()]]: <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); // Tarjeta inicializada y archivo abierto para lectura while (archivo.available()){ Serial.write((archivo.read()); } archivo.close(); } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] snuvcdjy5wx7jyecpx5e71n68rwl92d 0 477 4689 4617 2019-07-07T01:25:10Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Cerramos el archivo, y recién en este momento los datos se guardan en la SD, pudiendo extraer de forma segura nuestra SD. == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.close(); </pre> == Parámetros == Nada. == Retorna == == Advertencias == == Comentarios == == Ejemplo == <syntaxhighlight lang="c++"> Pendiente </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] rjjumflsgrwwvw7dtbqrio7ocoqw1iu 0 456 4628 4591 2019-07-03T21:25:59Z Kike GL 2 /* Sintaxis */ wikitext text/x-wiki == Descripción == Fuerza la actualización de los datos en la tarjeta SD (y el atributo del tamaño del archivo en caso de que haya crecido). == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.flush(); </pre> == Parámetros == Nada. == Retorna == Nada. == Comentarios == Esta es una opción ya que, como en la [[SD|página principal de esta librería]] se mencionó, es un flujo de datos por bloques; lo que quiere decir que escribir datos no lo hace inmediatamente al medio físico (por cuestiones de rendimiento), sino que primero los registra en [[SRAM]] mediante una caché. Cuando esta se llene, automáticamente debe escribir esos datos al medio físico (la tarjeta SD) para así poder seguir con la escritura. Este proceso de actualización ocurre en alguna de las siguientes situaciones: * Al llamar esta función (manualmente). * Al cambiar de bloque de datos (cada 512 bytes) si el que está en caché ha cambiado su contenido tras su lectura. * Al cerrar el archivo (aplica la misma regla de la anterior). * En cada intento de escritura si el archivo se abre con la opción '''O_SYNC'''. == Advertencias == * No se recomienda abusar de esta función, no solo por tema de rendimiento sino por tema de desgaste en la tarjeta SD. * Esta función siempre fallará si la instancia representa un directorio o carpeta; o el archivo no fue abierto para escritura. == Ejemplo 1 == <syntaxhighlight lang="c++"> // Pendiente </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == * [https://www.arduino.cc/en/Reference/FileFlush Referencias] [[Category:Libreria SD]] qzoafcrih0hx2oqelddbye5ah49bj56 0 478 4625 2019-07-03T20:17:09Z Kike GL 2 Página creada con «== Descripción == Método de la '''clase File''' (fichero/archivo) o directorio (carpeta) dentro de la tarjeta SD; con este se interactúa directamente sobre ellos. {{Tip...» wikitext text/x-wiki == Descripción == Método de la '''clase File''' (fichero/archivo) o directorio (carpeta) dentro de la tarjeta SD; con este se interactúa directamente sobre ellos. {{Tip|Los directorios (o carpetas) son tipos especiales de archivos, esta función informa si el archivo actual es un directorio o no.}} == Sintaxis == <pre> File dir = SD.open(ruta); File archivo = dir.isDirectory(); </pre> == Parámetros == ;ruta:Directorio o carpeta ;dir:Nombre de variable a instanciar. ;archivo:Nombre de variable a instanciar. == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> #include <SD.h> File root; void setup(){ Serial.begin(9600); pinMode(10, OUTPUT); SD.begin(10); root = SD.open("/"); //Instancia clase File printDirectory(root, 0); Serial.println("*** Listo ***"); } void loop(){ //Nada } void printDirectory(File dir, int numTabs) { while(true) { File archivo = dir.openNextFile(); //Instancia clase File if (!archivo) { Serial.println("** no mas archivos **"); break; } for (byte i=0; i<numTabs; i++) { Serial.print('\t'); } Serial.print(archivo.name()); if (archivo.isDirectory()) { Serial.println("/"); printDirectory(archivo, numTabs+1); }else{ Serial.print("\t\t"); Serial.println(archivo.size()); } } } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias externas == * [https://www.arduino.cc/en/Reference/FileIsDirectory Referencias] [[Category:Libreria SD]] fcp9usx1fv7wh762yhg27uduk2k23qj 0 474 4598 4586 2019-07-03T19:18:26Z Kike GL 2 /* Sintaxis */ wikitext text/x-wiki == Descripción == Retorna el nombre del archivo o directorio. == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.name(); </pre> == Parámetros == Nada. == Retorna == El nombre del archivo o directorio, o una cadena vacía si la instancia representa un archivo que nunca se abrió ([[char]]* o [[string]]). == Comentarios == * Cerrar el archivo no borra esta información; por lo tanto, permanece accesible aún después de explícitamente haber ordenado el cierre. Cabe aclarar que si el archivo no se logró abrir desde el principio, este dato se halla vacío. * Si la instancia fue creada mediante [[SD.open()]], se retornará una copia (truncada a 12 caracteres) del nombre ingresado en el primer parámetro (la ruta no forma parte del nombre). * Si la instancia fue creada mediante [[File.openNextFile()]], se retornará la versión 8.3 del nombre del archivo/directorio en cuestión. Si el archivo/directorio fue creado mediante un sistema con soporte para LFN (ej.: un PC), el nombre retornado aquí podría parecer extraño si se violó alguna regla de los nombres 8.3. Por ejemplo: '''Mis frases favoritas.txt''' podría aparecer como '''MISFRA~1.TXT'''. * La versión mejorada de esta librería ('''SdFat''') hace esta función "obsoleta", sugiriendo que se utilice '''getName()''' en su lugar (por la añadida compatibilidad con LFN). == Advertencias == * El retorno debe considerarse como una cadena de sólo lectura, de lo contrario se corre el riesgo de corromper la instancia (o incluso más allá todavía). == Ejemplo 1 == <syntaxhighlight lang="c++"> void setup() { // Inicializaciones File raiz = SD.open("/"); if (!raiz) { Serial.println("Error de apertura"); return; } Serial.println("Archivos en la raiz:"); File actual; while ((actual = raiz.openNextFile())) { Serial.print(actual.name()); Serial.print("\t\t\t"); if (actual.isDirectory()) { Serial.println("Directorio"); } else { Serial.print(actual.size()); Serial.println(" bytes"); } actual.close(); } } void loop() { //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == * [https://www.arduino.cc/en/Reference/FileName Referencias] [[Category:Libreria SD]] mk1qknpvyvkaotmtl7ycj56sznku90u 0 476 4624 4623 2019-07-03T20:09:07Z Kike GL 2 /* Parámetros */ wikitext text/x-wiki == Descripción == Método de la '''clase File''' (fichero/archivo) o directorio (carpeta) dentro de la tarjeta SD; con este se interactúa directamente sobre ellos. == Sintaxis == <pre> File dir = SD.open(ruta); File archivo = dir.openNextFile(); </pre> == Parámetros == ;ruta:Directorio o carpeta ;dir:Nombre de variable a instanciar. ;archivo:Nombre de variable a instanciar. == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> #include <SD.h> File root; void setup(){ Serial.begin(9600); pinMode(10, OUTPUT); SD.begin(10); root = SD.open("/"); printDirectory(root, 0); delay(2000); Serial.println(); Serial.println("Rewinding, and repeating below:" ); Serial.println(); delay(2000); root.rewindDirectory(); printDirectory(root, 0); root.close(); } void loop(){ //Nada } void printDirectory(File dir, int numTabs){ while (true){ File archivo = dir.openNextFile(); if (!archivo){ if (numTabs == 0){ Serial.println("** Listo **"); } return; } for (byte i=0; i<numTabs; i++){ Serial.print('\t'); } Serial.print(archivo.name()); if (archivo.isDirectory()){ Serial.println("/"); printDirectory(archivo, numTabs + 1); }else{ Serial.print("\t\t"); Serial.println(archivo.size()); } archivo.close(); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias externas == * [https://www.arduino.cc/en/Reference/FileOpenNextFile Referencias] [[Category:Libreria SD]] 5pi3jlpq4gnqv1jajsc9rs10vk71e35 0 446 4597 4426 2019-07-03T19:18:12Z Kike GL 2 /* Sintaxis */ wikitext text/x-wiki == Descripción == Devuelve el siguiente byte (carácter) del archivo, sin avanzar al siguiente. Es decir, las llamadas sucesivas a '''peek()''' devolverán el mismo carácter, al igual que la próxima llamada a [[File.read()]]. El valor recuperado es relativo a la [[File.position()|posición del "cursor"]]. == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.peek(); </pre> == Retorno == El valor recuperado, o -1 si no hay datos para leer ([[int]]). Esto último puede deberse a que se alcanzó el final del archivo, porque está cerrado o porque no fue abierto para lectura. == Advertencias == * Si por error no se verifica de antemano si hay datos disponibles, '''peek()''' retornará 255 para [[byte]] en el caso que el valor real sea -1 (nada). * Esta función siempre fallará si la instancia representa un directorio o carpeta. == Ejemplo == <syntaxhighlight lang="c++"> // Pendiente de hacer void setup() { } void loop() { } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] k6esalkznm80wauxgsbxdv3fw1nmyw1 0 472 4599 4579 2019-07-03T19:18:39Z Kike GL 2 /* Sintaxis */ wikitext text/x-wiki == Descripción == Retorna la posición actual del "cursor" del archivo. Si retorna '''0''' significa que se encuentra al inicio; si retorna el mismo valor de [[File.size()]] significa que se encuentra al final. == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.position(); </pre> == Parámetros == Nada. == Retorna == La posición actual en bytes del "cursor", o -1 si la instancia representa un directorio/carpeta o archivo sin abrir. ([[unsigned long]]). == Advertencias == * -1 en [[unsigned long]] equivale a 4294967295, lo cual puede resultar confuso si se está interactuando con un archivo cuyo tamaño alcanza el límite. En ese caso, se recomienda verificar directamente el tamaño y el estar abierto, con tal de salir de dicha confusión. == Comentarios == Se habla de un "cursor" posicionado en bytes porque la librería trata internamente los archivos como vectores/matrices de tipo [[byte]], y con la posibilidad de crecer automáticamente según la necesidad. Lo que hace esta función es retornar el índice (como el de un vector/matriz) actualmente en uso para la próxima lectura ([[File.read()]] o [[File.peek()]]) o escritura ([[File.write()]]/[[File.print()]]). == Ejemplo == <syntaxhighlight lang="c++"> // Así es como se retrocede una línea de texto void retrocederLinea() { if (!archivo.position()) return; // No se puede retroceder si estamos al principio del archivo retrocede(); if (archivo.peek() == '\r') retrocede(); // Esto se hace cuando el salto de línea se compone de dos caracteres while (archivo.position() && archivo.peek() != '\n') retrocede(); // Así es como se retrocede if (archivo.position()) archivo.read(); // Esto sucede solo si el comienzo de la línea NO es también el comienzo del archivo. } // Asumiendo que 'archivo' sea una variable global bool retrocede() { return archivo.seek(archivo.position() - 1); } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] 5w3gnfucij0sq3sk2d87glabsemhcrd 0 450 5088 5087 2019-10-14T22:24:41Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Escribe (al archivo) un dato mediante la representación textual de su valor, haciendo esta función útil para archivos de texto plano (ej.: .txt, .csv). Si el [[File.position()|"cursor"]] está posicionado al final del archivo (o alcanza dicho punto en el proceso), esta función lo hará crecer lo necesario para que todos los datos sean escritos. El tope de este crecimiento está en el espacio libre del "volumen" o al alcanzar los 4 GB (4294967295 bytes) de tamaño. Si este "cursor" no está posicionado al final del archivo, entonces esta función sobrescribirá datos existentes (a partir de la posición actual); lo que hace un tanto difícil editar de esta manera texto en el archivo (imagínalo como un editor de texto dónde la tecla de retroceso no funciona, siempre en modo sobrescribir sin que se pueda cambiar al típico modo insertar, y que cada salto de línea en medio de algo borre dos caracteres en la nueva línea). {{Nota|ya que es una implementación de [[Stream]], los detalles mencionados en [[Stream.print()]] y [[Serial.print()]] también aplican aquí.}} == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.print(cadena); archivo.print(variable[, formato]); </pre> == Parametros == ;cadena: Un [[string]] o [[String]]. También se valen literales (texto entrecomillado) y constantes [[F()]]. ;variable: variable a evaluar. Esta variable puede ser de cualquier tipo. ;formato: por defecto es '''DEC''', pero puedes también usar '''HEX''', '''OCT''' o '''BIN'''. También puede ser un valor del 0 al 7 si '''variable''' es un punto flotante, representaría la cantidad de cifras decimales a imprimir (2 por defecto). {{Tip|Equivaldría al [[File.write()]] de un solo [[byte]] si '''variable''' es de tipo [[char]].}} == Retorna == La cantidad de caracteres que se llegaron a escribir en el proceso ([[int]]). Puede fallar si el archivo no puede crecer, si no está abierto o no fue abierto para escritura. == Comentarios == Los literales de caracteres y cadenas también pueden representar caracteres especiales que son difíciles o imposibles de expresar de otra manera en el código fuente de un programa, como "nueva linea" (\n) o "tab" (\t). Estos caracteres especiales son todos precedidos por un carácter de barra diagonal inversa (\). {| class="wikitable col1cen" |+Codigos de escape !Código!!Descripción!!ASCII!!DEC |- |\n||nueva línea||LF||10 |- |\r||retorno de carro||CR||13 |- |\t||tabulacion horizontal||HT||9 |- |\v||tabulacion vertical||VT||11 |- |\b||retroceso||BS||8 |- |\f||salto de página||FF||12 |- |\a||alerta (pitido)||BELL||7 |- |\'||comilla simple||'||39 |- |\"||comillas dobles||"||34 |- |\?||signo de interrogación||?||63 |- |\\||barra invertida||\||47 |} == Advertencias == * Esta función siempre fallará si la instancia representa un directorio o carpeta. == Ejemplo == <syntaxhighlight lang="c++"> // Loggear lecturas analógicas while (!digitalRead(boton)) { archivo.println(analogRead(A0)); // Ya sé que no es print() exactamente, pero se usa de la misma manera. } archivo.close(); </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias externas == [[Category:Libreria SD]] 8ixs6qqncukcy6qmyhtkbepemis0et4 0 455 5086 4603 2019-10-14T22:23:30Z Kike GL 2 /* Retorna */ wikitext text/x-wiki == Descripción == Cumple exactamente la misma función que [[File.print()]], salvo que además agrega un salto de línea (el caracter de retorno del carro y nueva línea, o el literal '''"\r\n"'''). Si el [[File.position()|"cursor"]] está posicionado al final del archivo (o alcanza dicho punto en el proceso), esta función lo hará crecer lo necesario para que todos los datos sean escritos. El tope de este crecimiento está en el espacio libre del "volumen" o al alcanzar los 4 GB (4294967295 bytes) de tamaño. Si este "cursor" no está posicionado al final del archivo, entonces esta función sobrescribirá datos existentes (a partir de la posición actual); lo que hace un tanto difícil editar de esta manera texto en el archivo (imagínalo como un editor de texto dónde la tecla de retroceso no funciona, siempre en modo sobrescribir sin que se pueda cambiar al típico modo insertar, y que cada salto de línea en medio de algo borre dos caracteres en la nueva línea). {{Nota|ya que es una implementación de [[Stream]], los detalles mencionados en [[Stream.print()]] y [[Serial.print()]] también aplican aquí.}} == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.println(); archivo.println(cadena); archivo.print(variable[, formato]); </pre> {{Tip|La primera sintaxis se usa para agregar solamente el salto de línea.}} == Parametros == ;cadena: Un [[string]] o [[String]]. También se valen literales (texto entrecomillado) y constantes [[F()]]. ;variable: variable a evaluar. Esta variable puede ser de cualquier tipo. ;formato: por defecto es '''DEC''', pero puedes también usar '''HEX''', '''OCT''' o '''BIN'''. También puede ser un valor del 0 al 7 si '''variable''' es un punto flotante, representaría la cantidad de cifras decimales a imprimir (2 por defecto). == Retorna == La cantidad de caracteres que se llegaron a escribir en el proceso ([[int]]). Puede fallar si el archivo no puede crecer, si no está abierto o no fue abierto para escritura. == Comentarios == Los literales de caracteres y cadenas también pueden representar caracteres especiales que son difíciles o imposibles de expresar de otra manera en el código fuente de un programa, como "nueva linea" (\n) o "tab" (\t). Estos caracteres especiales son todos precedidos por un carácter de barra diagonal inversa (\). {| class="wikitable col1cen" |+Codigos de escape !Código!!Descripción!!ASCII!!DEC |- |\n||nueva línea||LF||10 |- |\r||retorno de carro||CR||13 |- |\t||tabulacion horizontal||HT||9 |- |\v||tabulacion vertical||VT||11 |- |\b||retroceso||BS||8 |- |\f||salto de página||FF||12 |- |\a||alerta (pitido)||BELL||7 |- |\'||comilla simple||'||39 |- |\"||comillas dobles||"||34 |- |\?||signo de interrogación||?||63 |- |\\||barra invertida||\||47 |} == Advertencias == * Esta función siempre fallará si la instancia representa un directorio o carpeta. == Ejemplo == <syntaxhighlight lang="c++"> // Loggear lecturas analógicas while (!digitalRead(boton)) { archivo.println(analogRead(A0)); } archivo.close(); </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] d8a8iy1ayqiioct32jpl1fsep8ogdel 0 445 4594 4593 2019-07-03T19:17:14Z Kike GL 2 /* Sintaxis */ wikitext text/x-wiki == Descripción == Lee un byte/caracter del archivo, y además avanza al siguiente. El valor recuperado es relativo a la [[File.position()|posición del "cursor"]]. == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.read() archivo.read(buffer, tamanio); </pre> == Parametros == ;buffer: una matriz de cualquier tipo, aunque usualmente de tipo [[byte]] o [[char]] (en la implementación se declara como puntero de tipo [[void]]). ;tamanio: el tamaño de dicha matriz '''en bytes'''. ([[unsigned int]]). == Retorno == * Para la primera, el valor recuperado, o -1 si no hay datos para leer ([[int]]). Esto último puede deberse a que se alcanzó el final del archivo, porque está cerrado o porque no fue abierto para lectura. * Para la segunda, la cantidad de bytes leídos exitosamente ([[unsigned int]]). Si retorna cero, es porque no logró leer nada. == Advertencias == * Si por error no se verifica de antemano si hay datos disponibles, '''read()''' retornará 255 para [[byte]] en el caso que el valor real sea -1 (nada). * Esta función siempre fallará si la instancia representa un directorio o carpeta. == Comentarios == A pesar de que la segunda sintaxis hace lo mismo que [[Stream.readBytes()|readBytes()]] (y que además se puede utilizar con normalidad), se recomienda la aquí mencionada debido a que es más eficiente para la obtención de múltiples bytes que su contraparte "genérica". == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); // Tarjeta inicializada y archivo abierto para lectura File archivo = SD.open("archivo.txt", FILE_WRITE); int dato; while ((dato = archivo.read()) >= 0){ Serial.write(dato); //Imprime caracter leído } archivo.close(); } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] nz1182gb9m7ecsmt9fkbvuoqr3f1ihz 0 479 4626 2019-07-03T20:23:17Z Kike GL 2 Página creada con «== Descripción == Método de la '''clase File''' (fichero/archivo) o directorio (carpeta) dentro de la tarjeta SD; con este se interactúa directamente sobre ellos. {{Tip...» wikitext text/x-wiki == Descripción == Método de la '''clase File''' (fichero/archivo) o directorio (carpeta) dentro de la tarjeta SD; con este se interactúa directamente sobre ellos. {{Tip|Los directorios (o carpetas) son tipos especiales de archivos, esta función informa si el archivo actual es un directorio o no.}} == Sintaxis == <pre> File dir = SD.open(ruta); File archivo = dir.rewindDirectory(); </pre> == Parámetros == ;ruta:Directorio o carpeta ;dir:Nombre de variable a instanciar. ;archivo:Nombre de variable a instanciar. == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> #include <SD.h> File root; void setup(){ Serial.begin(9600); pinMode(10, OUTPUT); SD.begin(10); root = SD.open("/"); //Crea instancia clase File printDirectory(root, 0); Serial.println("done!"); } void loop(){ //Nada } void printDirectory(File dir, int numTabs) { while(true) { File archivo = dir.openNextFile(); //Crea instancia clase File if (!archivo) { dir.rewindDirectory(); break; } for (byte i=0; i<numTabs; i++) { Serial.print('\t'); } Serial.print(archivo.name()); if (archivo.isDirectory()) { Serial.println("/"); printDirectory(archivo, numTabs+1); }else{ Serial.print("\t\t"); Serial.println(archivo.size()); } } } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias externas == * [https://www.arduino.cc/en/Reference/FileRewindDirectory Referencias] [[Category:Libreria SD]] bvch8gt75zuyaxl6nwpkjssq86fnzlz 0 471 4660 4596 2019-07-04T21:07:40Z Kike GL 2 /* Ejemplo 1 */ wikitext text/x-wiki == Descripción == Coloca el "cursor" del archivo en la posición dada. '''0''' para volver al inicio, [[File.size()]] para colocarse al final. == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.seek(pos); </pre> == Parámetros == ;pos: la posición (en bytes) que se desea establecer en el "cursor" ([[unsigned long]]). == Retorna == '''true''' si fue posible cambiar dicha posición; '''false''' en caso contrario ([[bool]]). Puede fallar si el valor ingresado no comprende el rango entre cero y el tamaño actual del archivo. == Comentarios == Se habla de un "cursor" posicionado en bytes porque la librería trata internamente los archivos como vectores/matrices de tipo [[byte]], y con la posibilidad de crecer automáticamente según la necesidad. Lo que hace esta función es cambiar el índice (como el de un vector/matriz) al cuál se quiere acceder la próxima vez; para así recuperar ([[File.read()]] o [[File.peek()]]) el valor almacenado en dicho lugar, o modificarlo ([[File.write()]]/[[File.print()]]). == Advertencias == * Esta función siempre fallará si la instancia representa un directorio o carpeta; o si el archivo no está abierto. == Ejemplo 1 == Funcion de leer registro. <syntaxhighlight lang="c++"> bool leerRegistro(Registro* r, unsigned int posicion) { if (archivo.seek(posicion * sizeof(r))) { return archivo.read(r, sizeof(r)); // Si se logra leer algo, equivale a retornar true }else{ return false; } } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == * [https://www.arduino.cc/en/Reference/FileSeek Referencias] [[Category:Libreria SD]] fenklw4p818fcp9qk6is893spyx18op 0 473 4600 4583 2019-07-03T19:18:51Z Kike GL 2 /* Sintaxis */ wikitext text/x-wiki == Descripción == Retorna el tamaño del archivo. Su valor inicia en cero cuando se abre uno recién creado o con la opción '''O_TRUNC'''. == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.size(); </pre> == Parámetros == Nada. == Retorna == El tamaño en bytes del archivo, o 0 si la instancia representa un directorio/carpeta o archivo sin abrir. ([[unsigned long]]). == Advertencias == * Ya que el valor cero también se retorna en archivos sin contenido, se recomienda verificar directamente lo de estar abierto y si es un directorio/carpeta, con tal de evitar confusión. == Ejemplo == <syntaxhighlight lang="c++"> unsigned long tamanioEnElementos() { return archivo.size() / sizeof(Registro); } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] hkxehvorur1l81j4ktmx5wk7rzdjryh 0 449 4604 4432 2019-07-03T19:21:06Z Kike GL 2 /* Sintaxis */ wikitext text/x-wiki == Descripción == Escribe datos binarios ("crudos") al archivo, haciendo esta función útil para archivos binarios (con contenido diferente al texto plano). Si el [[File.position()|"cursor"]] está posicionado al final del archivo (o alcanza dicho punto en el proceso), esta función lo hará crecer lo necesario para que todos los datos sean escritos. El tope de este crecimiento está en el espacio libre del "volumen" o al alcanzar los 4 GB (4294967295 bytes) de tamaño. Si este "cursor" no está posicionado al final del archivo, entonces esta función sobrescribirá datos existentes (a partir de la posición actual); lo que hace un tanto difícil reemplazar valores en registros de longitud variable. == Sintaxis == <pre> File archivo = SD.open("archivo.txt", FILE_WRITE); archivo.write(val); archivo.write(str); archivo.write(buf, len); </pre> == Parametros == ;val: Valor como un solo [[byte]] o variable (el byte menos significativo en caso de ser más grande). ;str: Cadena como una serie de bytes ([[string]]). ;buf: Matriz enviada como una serie de bytes ([[byte]]*). ;len: Largo de la matriz '''en bytes''' ([[int]]). == Retorno == La cantidad real de bytes que se escribieron con éxito ([[int]]). Puede fallar si el archivo no puede crecer, si no está abierto o no fue abierto para escritura. == Advertencias == * Para escribir los caracteres que representan los dígitos de un número, use la función [[File.print()]] en su lugar. * Esta función siempre fallará si la instancia representa un directorio o carpeta. == Ejemplo == <syntaxhighlight lang="c++"> while (Serial.available()) { archivo.write(Serial.read()); // Vuelca el contenido "crudo" o binario del puerto serial, al archivo } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] o2z0uzm1vslnc5mpqnlhm6scwrxn5u7 0 422 3233 2019-05-03T23:16:31Z Kike GL 2 Página creada con «== Descripción == La libreria [https://github.com/schinken/Flash Flash] de Mikal Hart, que permite el acceso facil a la memoria Flash. == Placas aplicables == == Sintaxi...» wikitext text/x-wiki == Descripción == La libreria [https://github.com/schinken/Flash Flash] de Mikal Hart, que permite el acceso facil a la memoria Flash. == Placas aplicables == == Sintaxis == <pre> </pre> == Métodos == == Comentarios == == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] [[Category:Librerias]] l0rd05wr786skult2uj61rpit9ltpeo 0 248 3755 1024 2019-05-06T22:17:11Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Estructuras de control</categorytree> == Referencias == [[Category:Estructuras de control]] owhftcjoep9mx6gdloryrwklf4owjuv 0 2 5070 5069 2019-10-13T13:39:31Z Kike GL 2 /* Trigonométricas */ wikitext text/x-wiki Para controlar la placa Arduino y realizar cálculos. == E/S digitales == Funciones especificas de Arduino para manejar los puertos de salida digitales. * [[pinMode()]] * [[digitalRead()]] * [[digitalWrite()]] * [[Programacion avanzada]] == E/S analógicas == Funciones especificas de entrada analogica y salida analogica simulada (PWM). * [[analogRead()]] * [[analogWrite()]] - PWM * [[analogReference()]] * [[analogReadResolution()]] - solo [[DUE]] y [[ZERO]] * [[analogWriteResolution()]] - solo [[DUE]] y [[ZERO]] == E/S avanzadas == Otras funciones que actúan con las E/S de Arduino. * [[tone()]] * [[noTone()]] * [[pulseln()]] * [[pulselnLong()]] == Tiempos == Algunas funciones que te dan acceso a los temporizadores interno. * [[delay()]] * [[delayMicroseconds()]] * [[millis()]] * [[micros()]] * [[setTime()]] - TimeLib.h * [[timeStatus()]] - TimeLib.h * [[makeTime()]] - TimeLib.h * [[breakTime()]] - TimeLib.h * [[DateTime]] - RTClib.h * [[now()]] == Matemáticas == Funciones matemáticas que puedes usar para alterar datos numéricos. <categorytree mode=all>Funciones matematicas</categorytree> == Trigonométricas == Funciones trigonometricas básicas disponibles. <categorytree mode=all>Funciones trigonometricas</categorytree> == Caracteres == Funciones para consultar tipo de carácter. * [[strlen()]] * [[isAlpha()]] * [[isAlphaNumeric()]] * [[isAscii()]] * [[isControl()]] * [[isDigit()]] * [[isGraph()]] * [[isHexadecimalDigit()]] * [[isPrintable()]] * [[isPunct()]] * [[isSpace()]] * [[isLowerCase()]] * [[isUpperCase()]] * [[isWhiteSpace()]] == Conversiones de tipo == Cuando requieres convertir un tipo de dato en otro puedes usar estas funciones: * [[char()]] a [[char]] * [[byte()]] a [[byte]] * [[int()]] a [[int]] * [[word()]] a [[unsigned int]] * [[long()]] a [[long]] * [[float()]] a [[float]] Matrices * [[atoi()]] a [[int]] * [[atol()]] a [[long]] * [[strtoul()]] a [[unsigned int]] * [[atof()]] a [[float]] string: * [[itoa()]] * [[ltoa()]] String: * [[String()]] a objeto [[String]] == Random == Para trabajar con números pseudo-aleatorios en Arduino. * [[random()]] * [[randomSeed()]] == Bit y Bytes == Funciones que pueden actuar sobre uno o mas bits. <categorytree mode=all>Funciones bit y byte</categorytree> == Interrupciones externas == Las interrupciones (ISR) son un método de disparar un evento sin esperar que el programa principal ([[loop()]]) llegue el turno de alguna instrucción particular. * [[attachInterrupt()]] * [[detachInterrupt()]] * [[digitalPinToInterrupt()]] * [[interrupts()]] * [[noInterrupts()]] == Funciones de puesto serie == <categorytree mode=all>Serial</categorytree> == Funciones de String == <categorytree mode=all>String</categorytree> == Funciones de usuario == Las funciones de usuario son la oportunidad de rehusar un bloque de código simplemente invocandolo. * [[Funciones de usuario]] == Puerto comunicaciones == Estos son algunos puertos de comunicación y algunos protocolos disponibles en Arduino. * [[Serial]] * [[SPI]] * [[Wire]] o I2C * [[CAN]] * [[RS-485]] == Clases y objetos == Algunas clases disponibles en Arduino. Debes primero instancias un objeto de la clase y luego podrás aplicar las propiedades y métodos de dicha clase. * [[String]] * [[Stream]] == USB == Solo placas ATmega32u4, [[DUE]] y [[Zero]]. * [[Keyboard]] * [[Mouse]] == Vea también == * [[Estructura]] * [[Variables]] [[Category:Referencias]] 4njhxb132jkx4hzn710rdbfby5y3jmm 0 404 2939 2938 2019-04-22T22:21:25Z Kike GL 2 /* Ejemplo 2 */ wikitext text/x-wiki Una '''función de usuario''' es un bloque de código que tiene un nombre y un conjunto de instrucciones que son ejecutadas cuando se invoca a la función por su nombre. Normalmente son escritas para realizar tareas repetitivas y para reducir el tamaño del código. Segmentar el código en funciones permite crear piezas de código que hacen una determinada tarea y volver al área del código desde la que han sido llamadas. {{Nota|Pueden declararse en cualquier parte fuera de setup() y loop().}} == Sintaxis == <pre> tipo nombre([parametros]){codigo} </pre> == Parámetros == ;tipo:Es el tipo de dato que devolverá con [[return]]. Use [[void]] para no devolver ningún dato. ;nombre:Nombre de la función. ;parámetros:Parámetros que serán enviados al invocar a función ;código:Conjunto de instrucciones a ejecutar == Advertencias == Siempre debe usarse () junto al nombre de la funcion. == Ejemplo 1 == <syntaxhighlight lang="c++"> </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); int a = 10; int b = 20; Serial.println(opera(a,b)); //27 Serial.println(opera(10,20)); //27 } void loop(){ //Nada } int opera(int n, int m) { n = n + 2; m = m - 5; return n+m; } </syntaxhighlight> == Vea también == * [[setup()]] * [[loop()]] * [[return]] * [[void]] == Referencias == * [https://aprendiendoarduino.wordpress.com/2016/11/16/funciones-definidas-por-usuario-2/ Aprendiendo Arduino] [[Category:Funciones]] oasv6u2rfw80vad0v83u3287zwiphnz 0 140 3224 3223 2019-05-03T22:51:00Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == La libreria [https://github.com/arduino-libraries/GSM GSM-h] de Arduino sirve para hacer/recibir llamadas de voz; enviar/recibir SMS y conectar a internet via redes GPRS con el modulo Quectel M10. == Placas aplicables == == Sintaxis == <pre> </pre> == Métodos == == Advertencias == == Ejemplo == <pre> </pre> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info All Libraryes] * [http://www.arduino.cc/en/Reference/GSM GSM] [[Category:Librerias]] 4an85vwf6yv0mobyipag71t87xvbc12 0 233 3743 1003 2019-05-06T22:11:50Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 134 3695 2722 2019-05-06T18:49:11Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Son palabras reservadas en el lenguaje Arduino. Usualmente son utilizados para expresar (en código fuente) un estado digital en un pin, aunque funcionalmente son iguales a [[true / false]]. == Sintaxis == <pre> digitalWrite(pin, estado); </pre> == Parámetros == ;pin: numero del pin digital (0~13 + 14~19). Arduino [[UNO]]. ;estado: puedes usar LOW o HIGH, aunque también equivalen a 0 o diferente de cero respectivamente. == Advertencia == * Nota que HIGH y LOW se deben escribir en mayusculas. * El significado de HIGH (en referencia a un pin) es algo diferente según se trate de si un pin se configura como INPUT (entrada) o como OUTPUT (salida). * Cuando un pin se configura como INPUT con [[pinMode()]] y se lee con [[digitalRead()]] HIGH si: ** Una tensión mayor de 3 voltios está presente en el pin (placas de 5 V) ** Una tensión mayor de 2 voltios está presente en el pin (placas de 3V3) * Un pin se puede configurar como INPUT con [[pinMode()]] y en consecuencia, ponerse a nivel HIGH con [[digitalWrite()]]. Esto habilitará las resistencias pullup internas de 20K, que provocará que el pin de entrada se ponga a nivel HIGH a menos que se lleve a nivel LOW por la circuitería externa. Así es como trabaja INPUT_PULLUP descrito más adelante con más detalle. * Cuando un pin se configura como OUTPUT con [[pinMode()]] y se activa a nivel HIGH con [[digitalWrite()]] el pin está a: ** 5 voltios (en placas alimentadas a 5 V); ** 3V3 voltios (en placas alimentadas a 3V3); * En este estado el pin actúa como fuente (source) de corriente, por ejemplo, encender un LED conectado a masa por medio de una resistencia limitadora. == Ejemplo 1 == Parpadeo de LED a bordo. <syntaxhighlight lang="c++"> unsigned long hora=0; void setup(){ pinMode(LED_BUILTIN, OUTPUT); } void loop(){ if (millis() - hora > 500){ hora = millis(); if (digitalRead(LED_BUILTIN)){ digitalWrite(LED_BUILTIN, LOW); //Apaga LED }else{ digitalWrite(LED_BUILTIN, HIGH); //Prende LED } } } </syntaxhighlight> == Ejemplo 2 == Parpadeo de LED a bordo. <syntaxhighlight lang="c++"> unsigned long hora=0; void setup(){ pinMode(LED_BUILTIN, OUTPUT); } void loop(){ if (millis() - hora > 500){ hora = millis(); if (digitalRead(LED_BUILTIN)){ digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); } } } </syntaxhighlight> == Vea también == * [[Palabras reservadas]] * [[true / false]] * [[INPUT / OUTPUT / INPUT_PULLUP]] * [[LED_BUILTIN]] * [[PI]] == Referencias externas == * [https://www.arduino.cc/reference/es/language/variables/constants/constants/ Niveles logicos en Arduino] [[Category:Palabras reservadas]] gc5y1vqhzv6p1gpgjnucs7nysyn38sm 0 336 4637 3815 2019-07-04T16:31:56Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == El '''Integrated Development Environment''' de Arduino es de fuente abierta. Existen versiones desktop para Windows, MAC y Linux. También existe un versión en linea. Consiste de un editor de textos, un compilador, ... == Archivos usados == Al crear un [[boceto]] en el IDE de Arduino , tiene acceso a una cantidad de extensiones de archivos diferentes para usar con sus archivos de código fuente. Cada uno tiene su propio uso particular que explicaré a continuación. ;.ino: Esta es la extensión principal para su(s) archivo(s) de croquis. El archivo de boceto primario debe ser un archivo .ino con el mismo nombre que el directorio en el que se encuentra. Puede crear archivos .ino adicionales en su boceto con el nombre que desee. Antes de la compilación, todos los archivos .ino adicionales se anexan al archivo de boceto primario. Se copian en orden ascendente según el nombre del archivo, y se ejecutan a través del proceso estándar de recopilación y generación de prototipos. ;.pde: Esta es la extensión predeterminada para bocetos escritos para Arduino IDE antes del lanzamiento de la versión 1.0. si usa una versión IDE de al menos 1.0.0 o superior, debe cambiar el nombre de su archivo de boceto de .pde a .ino . También mantenga su IDE actualizado, las versiones anteriores a la 1.0 no admiten muchas bibliotecas nuevas debido a cambios significativos en la API central de Arduino . ;.h: Los archivos de encabezado o los archivos con la extensión .h pueden utilizarse de varias maneras. Si su boceto usa un conjunto de constantes que pueden usar múltiples archivos .cpp o .ino , puede crear una sola ubicación para sus variables comunes. Las funciones que se definen en diferentes archivos .cpp pueden tener sus declaraciones colocadas en un encabezado para facilitar su reutilización. ;.cpp: Esta extensión es un archivo fuente C++. A veces, un boceto se vuelve bastante grande y puede utilizar un archivo .cpp para separar las secciones de su código. Las definiciones dentro de un archivo .cpp al que desea acceder en otro lugar deben tener sus declaraciones dentro de un archivo de encabezado (.h). Esto permite que su boceto incluya el encabezado y su funcionalidad. También un punto importante es; sus archivos .cpp no pasan por las modificaciones de precompilación de IDE y, por lo tanto, no generan prototipos. Para obtener más información sobre el uso de varios archivos, visite este artículo: Romper un boceto en varios archivos . ;.do: Si desea escribir el código C y usarlo dentro de Arduino, necesita usar una extensión .c en lugar de un archivo .cpp . Sin embargo, usar un archivo .c por sí solo no es la solución completa, visite estas Preguntas frecuentes para obtener más información. == Bocetos == Los programas escritos usando el software Arduino (IDE) se llaman [[boceto]]s (sketch). Estos bocetos están escritos en el editor de texto y se guardan con la extensión de archivo .ino. El editor tiene funciones para cortar/pegar y para buscar/reemplazar texto. El área de mensajes brinda comentarios al guardar y exportar y también muestra los errores. La consola muestra el texto generado por el software Arduino (IDE), incluidos los mensajes de error completos y otra información. La esquina inferior derecha de la ventana muestra la placa configurada y el puerto serie usado. Los botones de la barra de herramientas le permiten verificar y cargar programas, crear, abrir y guardar bocetos, y abrir el monitor en serie. == Monitor serie == Muestra los datos en serie que se envían desde la placa Arduino via USB. Para enviar datos a la pizarra, ingrese el texto y haga clic en el botón "enviar" o presione enter. Elija la velocidad en baudios del menú desplegable que coincida con la velocidad que configuro con la función Serial.begin(baudios) en su boceto. Tenga en cuenta que en Windows, MAC o Linux, la placa Arduino se reiniciará (vuelva a ejecutar la ejecución de su boceto al comienzo) cuando se conecte con el monitor serie. También puede hablar con la pizarra desde Processing, Flash, MaxMSP , etc. == Serial Plotter == Desde la versión 1.6.6 del IDE de Arduino se dispone de una herramienta llamada Serial Plotter que nos permite hacer gráficas múltiples de los datos enviados por Arduino vía puerto serie. Sirve principalmente para hacer análisis de la forma de onda. Es un trazador de gráficos con desplazamiento en el eje x (500 puntos en el ancho total), diferentes colores para cada variable, admite valores negativos ya que el eje y se ajusta automáticamente. Para imprimir mas de una variable deje un espacio entre los datos con " " o "\t". Puedes cargar un ejemplo desde 01.Basics <pre> void setup() { Serial.begin(115200); } void loop() { } </pre> Otro ejemplo: <pre> void setup(){ Serial.begin(115200); } void loop(){ int valor = random(0,100); Serial.println(valor); delay(1); } </pre> == Comentarios == Existen dos tipos de [[Comentarios]] == Include == Se usa para incluir librerías externas en su [[boceto]]. Esto le da al programador acceso a un gran grupo de librerías C estándar prefabricadas que traen nuevos métodos y funciones. El nombre de la librería deberá estar entre simbolos < >. No debe poner terminador de punto y coma o el compilador dará un error. == Palabras reservadas == Las [[Palabras reservadas]] son las que cambian de color en el IDE Arduino. == Otros IDE == {|class="wikitable" !IDE!!Pugin!!Fuente |- |[http://www.sublimetext.com Sublime Text]||http://robot-will.github.io/Stino/||[http://forum.arduino.cc/index.php?topic=138014.0 Foro Arduino] |- |[http://notepad-plus-plus.org Noepad++]||http://sourceforge.net/projects/narduinoplugin/||[http://forum.arduino.cc/index.php/topic,141050.0.html Foro Arduino] |- |[http://www.eclipse.org/ Eclipse]||http://www.baeyens.it/eclipse/||http://playground.arduino.cc/Code/Eclipse |- |[http://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx VisualStudio]||colspan=2|http://www.visualmicro.com/ |- |[http://www.atmel.com/microsite/atmel_studio6/ ATmel Studio]||colspan=2|http://www.visualmicro.com/ |} == Vea también == * [[boceto]] * [[Estructura]] * [[Variables]] * [[Funciones]] * [[Palabras reservadas]] == Referencias == * [https://github.com/arduino/Arduino/ IDE Arduino] * [https://create.arduino.cc/editor Version IDE Arduino en linea] * [http://diymakers.es/guia-arduino/ Guia Arduino] - Diy Makers [[Category:Arduino]] leqd9tn1ft9dibd3dl8pcoly4ggjb2d 0 138 4131 4130 2019-06-02T17:19:34Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Son palabras reservadas usadas para definir en los pines digitales si se usara de entrada o salida. Cambia el comportamiento eléctrico del pin digital. * Pines digitales configurados como '''INPUT''' con [[pinMode()]] se dice que son en una alta impedancia estado. Demandas extremadamente pequeñas corrientes en el circuito, equivale a una resistencia en serie de 100 Mega ohmios. Usado para leer pulsadores. * Pines digitales configurados como '''OUTPUT''' con [[pinMode()]] se dice que estana baja impedancia. Esto significa que pueden proporcionar una cantidad sustancial de corriente a otros circuitos. Los pines digitales en Arduino pueden suministrar o resumir (absorber corriente) hasta maximo de 40 mA (miliamperios). Cargas superiores a 40 mA (por ejemplo, motores) requerirán un transistor u otro circuito de interfaz. {{Nota|Definir un pin digital como un INPUT, para leer un pulsador por ejemplo, cuando el interruptor está en estado abierto, el pin de entrada estará "flotando", lo que dará como resultado resultados impredecibles.}} == Sintaxis == <pre> pinMode[pin, tipo]; </pre> == Parámetros == ;pin: numero del pin digital (0~13 + 14~19). Puedes definir el numero de pin como [[const]] [[byte]]. ;tipo: puede ser INPUT / OUTPUT / INPUT_PULLUP == Advertencias == * Nota que INPUT, OUTPUT y INPUT_PULLUP se deben escribir en mayusculas. * En pines digitales OUTPUT la corriente maxima es de 40 mA. * En pines digitales INPUT no debe dejar al aire (estado no permitido). Dara valores erraticos. Debes usar una resistencia pull-up o pull-down de 10K. == Ejemplos == <syntaxhighlight lang="c++"> pinMode(2, INPUT); pinMode(3, OUTPUT); pinMode(4, INPUT_PULLUP); </syntaxhighlight> == Vea también == <categorytree mode=all>Palabras reservadas</categorytree> == Referencias externas == [[Category:Palabras reservadas]] t9jx4bpa2z7aq7tnrpf2dpjlav45l1q 0 245 3759 1016 2019-05-06T22:18:34Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Estructuras de control</categorytree> == Referencias == [[Category:Estructuras de control]] owhftcjoep9mx6gdloryrwklf4owjuv 0 371 4980 4918 2019-09-26T16:32:13Z Kike GL 2 wikitext text/x-wiki Esta es una sección que pretende recopilar '''Tips''' de todas partes que sean útiles a los usuarios. ;[[Tip 1]]:Como detener un [[boceto]] de Arduino. ;[[Tip 2]]:Como acceder a dispositivos desde fuera de la red sin IP publica fija. ;[[Tip 3]]:Diferencia entre [[delay()]] y [[millis()]] ;[[Tip 4]]:Como detectar el flanco de subida (RISSING) de un pulsador. ;[[Tip 5]]:Simplificar manejo masivo de pines. == Vea también == <categorytree mode=all>Tips</categorytree> == Referencias == * [http://arduino.land/FAQ/ Arduino Land] [[Category:Tips]] 0qi6lph8jjzi88974l0qnv16dpiifmm 0 124 332 2018-06-18T22:02:30Z Kike GL 2 Kike GL trasladó la página [[IsControl()]] a [[isControl()]] wikitext text/x-wiki #REDIRECCIÓN [[isControl()]] c7g0vejr4cc4s2pmgn2602wl9rd50fl 0 125 334 2018-06-18T22:02:55Z Kike GL 2 Kike GL trasladó la página [[IsDigit()]] a [[isDigit()]] wikitext text/x-wiki #REDIRECCIÓN [[isDigit()]] 70jfxssi77zl3s2k7o0zwqgyhp5sqy7 0 127 338 2018-06-18T22:04:25Z Kike GL 2 Kike GL trasladó la página [[IsGraph()]] a [[isGraph()]] wikitext text/x-wiki #REDIRECCIÓN [[isGraph()]] oai7arfdvlacw4ixcsqrvdwvai3y0m9 0 129 342 2018-06-18T22:05:10Z Kike GL 2 Kike GL trasladó la página [[IsHexadecimalDigit()]] a [[isHexadecimalDigit()]] wikitext text/x-wiki #REDIRECCIÓN [[isHexadecimalDigit()]] fal97757cvlpuzhimc3agsuamzfn6zg 0 123 330 2018-06-18T22:02:10Z Kike GL 2 Kike GL trasladó la página [[IsLowerCase()]] a [[isLowerCase()]] wikitext text/x-wiki #REDIRECCIÓN [[isLowerCase()]] 3u80bnjc6cbxeu050gcrmdz1vv2y84n 0 130 344 2018-06-18T22:06:33Z Kike GL 2 Kike GL trasladó la página [[IsPrintable()]] a [[isPrintable()]] wikitext text/x-wiki #REDIRECCIÓN [[isPrintable()]] 2rcfzsbhbxfnedoncffsxhsh09w8rlw 0 126 336 2018-06-18T22:03:34Z Kike GL 2 Kike GL trasladó la página [[IsPunct()]] a [[isPunct()]] wikitext text/x-wiki #REDIRECCIÓN [[isPunct()]] hoqwwav7zb4gq4f2pfhkq8a3neoyfe8 0 132 348 2018-06-18T22:08:00Z Kike GL 2 Kike GL trasladó la página [[IsSpace()]] a [[isSpace()]] wikitext text/x-wiki #REDIRECCIÓN [[isSpace()]] m2rdopfsaa2jo4htfxycbjwyee5jhem 0 128 340 2018-06-18T22:04:49Z Kike GL 2 Kike GL trasladó la página [[IsUpperCase()]] a [[isUpperCase()]] wikitext text/x-wiki #REDIRECCIÓN [[isUpperCase()]] d59y833gn6uwqbiia8e3v12n2zfit2l 0 131 346 2018-06-18T22:07:04Z Kike GL 2 Kike GL trasladó la página [[IsWhiteSpace()]] a [[isWhiteSpace()]] wikitext text/x-wiki #REDIRECCIÓN [[isWhiteSpace()]] th8gwiwmerulzo2s8tgrjtfbdwrjjrk 0 280 1061 2018-06-26T21:33:36Z Kike GL 2 Página creada con « == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Button mouse control]] Category:M...» wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Button mouse control]] [[Category:Mouse]] 8376k139t36z2f7uyvarnhxej7o4h83 0 277 1055 2018-06-26T21:30:19Z Kike GL 2 Página creada con « == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Keyboard logout]] * Keyboard repro...» wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Keyboard logout]] * [[Keyboard reprogram]] * [[Keyboard serial]] * [[Keyboard mouse control]] [[Category:Teclado]] ec6mfuitnus4bmwbm7qpm4w7qu1who7 0 273 1051 2018-06-26T21:29:28Z Kike GL 2 Página creada con « == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Keyboard logout]] * Keyboard repro...» wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Keyboard logout]] * [[Keyboard reprogram]] * [[Keyboard serial]] * [[Keyboard mouse control]] [[Category:Teclado]] ec6mfuitnus4bmwbm7qpm4w7qu1who7 0 274 1052 2018-06-26T21:29:47Z Kike GL 2 Página creada con « == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Keyboard logout]] * Keyboard messa...» wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Keyboard logout]] * [[Keyboard message]] * [[Keyboard reprogram]] * [[Keyboard serial]] [[Category:Teclado]] 9ur5251qkpo08a1atn2noohorox8uwp 0 275 1053 2018-06-26T21:29:59Z Kike GL 2 Página creada con « == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Keyboard logout]] * Keyboard messa...» wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Keyboard logout]] * [[Keyboard message]] * [[Keyboard serial]] * [[Keyboard mouse control]] [[Category:Teclado]] lfcn5q3umcl66w3wwu8qz9bhoqxhasf 0 276 1054 2018-06-26T21:30:10Z Kike GL 2 Página creada con « == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Keyboard logout]] * Keyboard messa...» wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Keyboard logout]] * [[Keyboard message]] * [[Keyboard reprogram]] * [[Keyboard mouse control]] [[Category:Teclado]] lgfe7o9ksimqrte16a0fbt8wkh4m5pe 0 497 5281 5280 2020-03-20T17:21:59Z Kike GL 2 /* Parámetros */ wikitext text/x-wiki == Descripción == Un teclado matricial es un dispositivo que agrupa en filas y columnas (de alli el nombre matricial, 3x3, 3x4, 4x4) varios pulsadores y permite controlarlos usando un número de pines inferior al que necesitaríamos al usarlos de forma individual. {{Tip|Al ser simples pulsadores actuaremos igual que con ellos, poniendo cada linea con un pull-up.}} == Sintaxis == <pre> #include <Keypad.h> Keypad teclado = Keypad(makeKeymap(keys), rowPins, colPins, filas, columnas); </pre> == Parámetros == ;keys:Matriz[filas][columnas] que contiene los caracteres representados ;rowPins:Pines digitales de filas ;colPins:Pines digitales de columnas ;filas:Numero de filas ;columnas:Numero de columnas == Métodos == {| class="wikitable" |+Métodos disponibles librería Keypad.h |- ! Método !! Descripción |- | getKey() || Retorna el valor ASCII de una tecla presionada o liberada en un teclado USB conectado. |- | getKeys() || |- | getState() || |- | isPressed() || |- | addEventListener() || |- | keyStateChanged() || |- | findKeyInList() || |- | bitMap() || |- | pin_mode() || |- | pin_read() || |- | pin_write || |- | findKeyInList() || |- | setDebounceTime() || |- | setHoldTime() || |- | waitForKey() || |} == Comentarios == == Advertencias == == Ejemplo 1 == <syntaxhighlight lang="c++"> #include <Keypad.h> const byte ROWS = 4; //filas const byte COLS = 3; //columnas char keys[ROWS][COLS] = { {'1','2','3'}, {'4','5','6'}, {'7','8','9'}, {'*','0','#'} }; byte rowPins[ROWS] = {5, 4, 3, 2}; //Pines para filas byte colPins[COLS] = {8, 7, 6}; //Pines para columnas Keypad teclado = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS); void setup(){ Serial.begin(9600); } void loop(){ char key = teclado.getKey(); if (key){ Serial.println(key); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias == * [http://playground.arduino.cc/Code/Keypad Playground] * [https://www.luisllamas.es/arduino-teclado-matricial Teclado matricial] - Luis Llamas * [https://www.prometec.net/teclados-matriciales/ Teclado matricial] - Prometec [[Category:Librerias]] [[Category:Libreria Keypad]] qkaqh6cbbvva0ayjppin4lfkfvufqyg 0 254 3738 1030 2019-05-06T22:09:25Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Sensores</categorytree> == Referencias == [[Category:Sensores]] phrz68vyt00mk72xrwh41yn8g07pld8 0 451 4634 4449 2019-07-04T16:29:38Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == La librería [https://github.com/arduino-libraries/LiquidCrystal LiquidCrystal] de Adafruid (AGO-2017), permite a un Arduino controlar un LCD (HD44780 y compatibles) via 4 u 8 bits de datos mas ademas de RS y Enable. Opcionalmente puedes usar la linea RW. Mucho mas eficiente es la libreria [https://github.com/marcoschwartz/LiquidCrystal_I2C LiquidCrystal_I2C] de Frank de Brabander (NOV-2015), que permite a un Arduino controlar un LCD via el bus [[Wire|I2C]], pero tendras que usar un adaptador. == Placas aplicables == Todas == Sintaxis == <pre> #include <LiquidCrystal.h> LiquidCrystal lcd(rs, en, d4, d5, d6, d7); LiquidCrystal lcd(rs, rw, en, d4, d5, d6, d7); LiquidCrystal lcd(rs, en, d0, d1, d2, d3, d4, d5, d6, d7); </pre> == Parametros == ;rs:el número del pin Arduino que está conectado al pin RS en la pantalla LCD. ;rw:el número del pin Arduino que está conectado al pin RW en la pantalla LCD (opcional). Si no se usa conectar a GND. ;en:el número del pin Arduino que está conectado al pin habilitar en la pantalla LCD. ;dx:el número del pin Arduino que está conectado a los pines de datos en la pantalla LCD. == Métodos == {| class="wikitable" |- ! Metodos !! Descripcion |- | begin(columnas, filas) || Inicializa la interfaz a la pantalla LCD y especifica las dimensiones de LCD. |- | setCursos(columna, fila) || Va a cierta posicion del LCD. |- | clear() || Limpia el LCD. <incluye un home(). |- | home() || Va a la posicion 0,0 (arriba a la izquierda) |- | print(dato [, base]) || Imprime un dato tipo [[char]], [[byte]], [[int]], [[long]]. Retorna el numero de bytes escritos. |- | write(datos) || Escribe datos tipo [[string]] o [[String]] en LCD. Retorna el numero de bytes escritos. |- | cursor() || Muestre el cursor LCD: un guión bajo (línea) en la posición en la que se escribirá el siguiente carácter. |- | noCursor() || Esconde cursos LCD. |- | blink() || Hace parpadear al cursor. |- | noBlink() || Deja fijo el cursor. |- | display() || Vuelve a mostrar el contenido del LCD. |- | noDisplay() || Esconde el contenido del LDC. |- | autoscroll() || Activa el auto scroll. |- | noAutoscroll() || Desactiva el auto scroll. |- | scrollDisplayLeft() || Desplaza toda la pantalla una columna a la izquierda. |- | scrollDisplayRight() || Desplaza toda la pantalla una columna a la derecha. |- | leftToRight() || Establece sentido de escritura de izquierda a derecha. |- | rightToLeft() || Establece sentido de escritura de derecha a izquierda. |- | createChar() || Crea un caracter personalizado. |- | setRowOffsets() || Configura las direcciones de memoria donde se almacenan los caracteres del LCD. |} == Comentarios == == Advertencias == == Ejemplo 1 == Ejemplo de LCD con manejo directo de 4 bits. <syntaxhighlight lang="c++"> /* The circuit: * LCD RS pin to digital pin 12 * LCD R/W pin to ground * LCD Enable pin to digital pin 11 * LCD D4 pin to digital pin 5 * LCD D5 pin to digital pin 4 * LCD D6 pin to digital pin 3 * LCD D7 pin to digital pin 2 * LCD VSS pin to ground * LCD VCC pin to 5V * 10K resistor: * ends to +5V and ground * wiper to LCD VO pin (pin 3) */ #include <LiquidCrystal.h> const int rs=12, en=11, d4=5, d5=4, d6=3, d7=2; LiquidCrystal lcd(rs, en, d4, d5, d6, d7); void setup() { lcd.begin(16, 2); //Columnas, filas lcd.print("Hola mundo..."); } void loop() { lcd.setCursor(0, 1); //Poner cursor en columna 0, fila 1 lcd.print(millis()/1000); } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> #include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { lcd.begin(16, 2); //Columnas, filas } void loop() { lcd.setCursor(0, 0); for (byte i=0; i<10; i++) { lcd.print(i); delay(500); } lcd.setCursor(16, 1); lcd.autoscroll(); //Prende scrolling for (byte i=0; i<10; i++) { lcd.print(i); delay(500); } lcd.noAutoscroll(); //Apaga scrolling lcd.clear(); //Limpia LCD } </syntaxhighlight> == Ejemplo 3 == En este ejemplo creamos 5 caracteres especiales y los intercambiamos a velocidades distintas. <syntaxhighlight lang="c++"> #include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); bool a,b; byte heart[8] = { 0b00000, 0b01010, 0b11111, 0b11111, 0b11111, 0b01110, 0b00100, 0b00000 }; byte smiley[8] = { 0b00000, 0b00000, 0b01010, 0b00000, 0b00000, 0b10001, 0b01110, 0b00000 }; byte frownie[8] = { 0b00000, 0b00000, 0b01010, 0b00000, 0b00000, 0b00000, 0b01110, 0b10001 }; byte armsDown[8] = { 0b00100, 0b01010, 0b00100, 0b00100, 0b01110, 0b10101, 0b00100, 0b01010 }; byte armsUp[8] = { 0b00100, 0b01010, 0b00100, 0b10101, 0b01110, 0b00100, 0b00100, 0b01010 }; void setup() { lcd.begin(16, 2); lcd.createChar(0, heart); lcd.createChar(1, smiley); lcd.createChar(2, frownie); lcd.createChar(3, armsDown); lcd.createChar(4, armsUp); lcd.setCursor(0, 0); lcd.print("I "); lcd.write(byte(0)); //heart lcd.print(" Arduino! "); } void loop() { if (millis()%500 < 5){ lcd.setCursor(13, 0); if (a){ lcd.write(1); //smiley }else{ lcd.write(2); //frownie } a = !a; } if (millis()%200 < 5){ lcd.setCursor(4, 1); if (b){ lcd.write(3); //armsDown }else{ lcd.write(4); //armsUp } b = !b; } } </syntaxhighlight> == Ejemplo 4 == Recibimos un texto desde consola y lo escribimos en el LCD. <syntaxhighlight lang="c++"> #include <LiquidCrystal.h> LiquidCrystal lcd(7, 6, 5, 4, 3, 2); void setup() { Serial.begin(9600); lcd.begin(16, 2); } void loop() { if (Serial.available()) { delay(100); lcd.clear(); byte n = 0; while (Serial.available()) { lcd.write(Serial.read()); delay(20); n++; if (n 16){ //Igual lcd.setCursor(0,1); } } } } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] * [https://www.arduino.cc/en/Reference/LiquidCrystal LiquidCrystal] * [http://diymakers.es/aprender-usar-un-display-lcd/ Aprender a usar un display LCD] - Diy Makers * [https://eldesvandejose.com/2016/04/02/la-libreria-liquidcrystal/ La libreria LiquidCrystal] - El desvan de José * [https://www.pjrc.com/teensy/td_libs_LiquidCrystal.html Liquid Crystal Library] - PJRC [[Category:Librerias]] h1jlv7qvc3oz2pqopyccb9ua4pesffw 0 137 3785 3784 2019-05-06T22:57:39Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Palabra reservada que identifica el LED a bordo. En prácticamente todo Arduino, está en el pin digital 13 (ese es el valor). {{Nota|Es indispensable declarar primero con [[pinMode()]] en OUTPUT.}} == Sintaxis == <pre> pinMode(LED_BUILTIN, OUTPUT) digitalWrite(LED_BUILTIN, estado); </pre> == Parámetros == ;estado: debe ser LOW o HIGH. También puedes usar 0 o false como sinomino de LOW y cualquier valor diferente de cero o true como sinomimo de HIGH. == Advertencias == Nota que LED_BUILTIN se debe escribir en mayúsculas. == Ejemplo 1 == Ejemplo de parpadeo del LED a bordo con [[delay()]]. <syntaxhighlight lang="c++"> void setup(){ pinMode(LED_BUILTIN, OUTPUT) } void loop(){ digitalWrite(LED_BUILTIN, HIGH); delay(500); digitalWrite(LED_BUILTIN, LOW); delay(500); } </syntaxhighlight> == Ejemplo 2 == Ejemplo de parpadeo del LED a borde sin usar [[delay()]]. <syntaxhighlight lang="c++"> unsigned long hora=0; void setup(){ pinMode(LED_BUILTIN, OUTPUT); } void loop(){ if (millis() - hora > 500){ hora = millis(); if (digitalRead(LED_BUILTIN)){ digitalWrite(LED_BUILTIN, LOW); //LOW = false = 0 }else{ digitalWrite(LED_BUILTIN, HIGH); //HIGH = true = 1 } } } </syntaxhighlight> == Ejemplo 3 == Ejemplo de parpadeo del LED a borde sin usar [[delay()]] muy simple. <syntaxhighlight lang="c++"> unsigned long hora=0; void setup(){ pinMode(LED_BUILTIN, OUTPUT); } void loop(){ if (millis() - hora > 500){ hora = millis(); digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Palabras reservadas</categorytree> == Referencias externas == [[Category:Palabras reservadas]] grvevsgxmhwxw6r42jz5nfbw5yuszc8 0 500 5112 5111 2019-12-12T01:14:42Z Kike GL 2 /* Ejemplo 1 */ wikitext text/x-wiki == Descripción == La libreria [https://github.com/wayoda/LedControl LedControl.h] de Eberhard Fahle para trabajar con MAX7219 o MAX7221 que maneja display 7 segmentos de catodo comun o matriz de LED 8x8. == Sintaxis == <pre> #include <LedControl.h> LedControl lc = LedControl(DIN,CLK,CS,n); </pre> == Parámetros == ;DIN:Entrada de datos (MOSI) ;CLK:Reloj (CSK) ;CS:Selector de chip (SS) ;n:Numero del MAX (0~7) == Métodos == {| class="wikitable" |+Metodos disponibles libreria LedControl.h |- ! Método !! Descripción !! Ejemplo |- | lc.shutdown() || TRUE apaga, FALSE para operación normal. || lc.shutdown(0,false) |- | lc.setIntensity() || Determina el brillo (0 a 15) || lc.setIntensity(0,4) |- | lc.setScanLimit() || Numero de dígitos a usar 0~7 || lc.setScanLimit(0,3) |- | lc.clearDisplay() || || lc.clearDisplay(0) |- | lc.setDigit() || Muestra un digito decimal. addr,digit,valor,dp || lc.setDigit(0,dig,num,false) |- | lc.setChar() || '0','1','2','3','4','5','6','7','8','9','0','A','b','c','d','E','F','H','L','P','.','-','_',' ' || lc.setChar(0,0'A?,false) |- | lc.setLed() || addr,row,col,state (true=on) || lc.setLed(0,0,0,true) |- | lc.setRow() || addr,row,value || lc.setRow(0,0,1) |- | lc.setColumn() || addr,col,value || lc.setColumn(0,0,1) |} == Comentarios == * Notese que al estar diseñado para cátodo común (CC) las salidas de cada dígito (que van al cátodo) son reforzadas (320 mA) mientras que los segmentos (que van al ánodo) son las imitadoras de corriente (max 40 mA) determinadas por Rset. Ademas gracias a la multiplexion solo un dígito esta prendido a la vez. * Para poner en cascada hasta ocho (8) MAX7219 se hacen comunes CLK (13) y LOAD (12). La data para el primer MAX7219 se mete en DIN (1) y para el siguiente se extrae de DOUT (25). * Cada CHIP puede manejar hasta 8 digitos en cuyo caso cada uno prendera 125 ms. Si usas menos digitos en un MAX sebe usar setScanLimit(0,n), si n=3 solo se activan 4 digitos y cada uno prenderia 167 ms. * Es importante entender que Rset es el control de brillo analógico y el método setIntensity() es el control de brillo digital, mediante modulación de PWM o ancho de pulso (Duty Cycle) entre 1/32 y 31/32. Para eso debemos ver en las especificaciones de nuestro LED la corriente máxima y la tensión directa. Por ejemplo si mi LED tiene una Imax de 25 mA y una tensión directa de trabajo de 2V elegiré Rset = 28kΩ, como no es comercial le pondré 33kΩ. == Advertencias == * Rset puede ser variable (lo que permite un control de brillo analógico) pero su valor minimo absoluto es 9K53. == Ejemplo 1 == Conectamos un MAX7219 con un display de 4 digitos y 7 segmentos y mostramos un contador ascendente en cada digito por un segundo y luego la palabra HELP durante 3 segundos. <syntaxhighlight lang="c++"> #include <LedControl.h> LedControl lc = LedControl(12,11,10,1); //El 1 al final indica cuantos MAX en cascada hay. Máximo 8. void setup(){ //Despierta display lc.shutdown(0,false); //Pone brillo en medio lc.setIntensity(0,8); //Limita a solo 4 digitos lc.setScanLimit(0,3); //Limpia display lc.clearDisplay(0); } void loop{ //Cuenta for (byte n=0, n<10, n++) { for (byte dig=0, dig<4; n++) { //Muestra display lc.setDigit(0, dig, n, false); delay(1000); } } lc.setChar(0,0,'H',false); lc.setChar(0,1,'E',false); lc.setChar(0,2,'L',false); lc.setChar(0,3,'P',false); delay(1000); //Apaga display lc.shutdown(0, true); lc.clearDisplay(0); delay(3000); //Prende display lc.shutdown(0, false); } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias == * [https://www.arduinolibraries.info/libraries All Libraries] * [https://www.maximintegrated.com/en/app-notes/index.mvp/id/1196 Using the MAX7219/7221 to drive higher voltage or current] - Maxim * [https://www.prometec.net/8x8-max7219/ Matriz LED 8x8 con MAX7219 y SPI] - Prometec * [https://naylampmechatronics.com/luces-iluminacion/265-kit-matriz-led-max7219.html Kit matriz LED MAX7219] - Naylamp Mechatronics * [https://www.luisllamas.es/matriz-led-arduino-max7219/ Encender una matriz LED con MAX7219] - Luis Llamas * [https://www.youtube.com/watch?v=Gc77CG5-TWo Capitulo 49 - Display 7 segmentos con MAX7219 y multiplexacion] - Bitwise Ar [[Category:Librerias]] [[Category:Libreria LedControl]] i11xt1ubk158jrerkw9azhbvyvdlkpx 0 111 4824 3173 2019-07-19T00:36:13Z Kike GL 2 /* Sincronización */ wikitext text/x-wiki Esta página incluye una lista de librerías contribuidas por la comunidad para Arduino. == Paginas huerfanas == * [[ChatServer]] * [[UDPSendReceiveString]] * [[WebClient]] * [[WebClientRepeating]] * [[WebServer]] == Audio == * [[Rttl]] - Ejecuta melodias Rttl * [[MusicWithoutDelay]] - Un algoritmo para tocar notas musicales más fácil, con la ayuda de la biblioteca de tonos de Bhagman, sin demora. * [[SinpleSDAudio]] * [[TMRpcm]] - Reproducción de audio PCM/WAV. * [[AudioFrequencyMeter]] - Obtener el tono fundamental de una señal de audio == Nube == * [[JustWifi]] - Administrador Wifi para ESP8266 (Xose Pérez) == Comunicaciones == * [[Wire]] Interfaz de dos hilos (I2C) para enviar y recibir datos a través de una red de dispositivos o sensores. * [[SoftWire]] * [[Ethernet]] para conectarse a Internet usando Arduino Ethernet Shield, Arduino Ethernet Shield 2 y Arduino Leonardo ETH * [[GSM]] para conectarse a una red GSM/GRPS con la protección GSM. * [[SPI]] para comunicarse con dispositivos que utilizan el bus de Interfaz Periférica Serial (SPI) * [[WiFi]] para conectarse a internet usando el escudo Arduino WiFi. * [[OneWire]] Acceda a sensores de temperatura de 1 cable, memoria y otros chips. * [[ArduinoMqtt]] Libreria de cliente MQTT para Arduino basada en el proyecto Eclipse Paho. * [[Conector CMMC MQTT]] Libreria de conetctores MQTT * [[MQTT]] Libreria MQTT para Arduino * [[ESP32 BLE Arduino]] Funciones BLE para ESP32. * [[Webbino]] es un servidor web para Arduino para NodeMCU. == Criptografía == == Estructura de datos y algoritmos == == Gráficos de datos == == Domótica e IoT (Internet de las cosas) == == De entrada y salida == === Botones y Debouncing === === Control LED === === Control LED múltiple === === Otra entrada / salida === == Control LED == == Control LED multiple == == Otra entrada / salida == == Interrupciones == == LCD == === Textuales LCD === === Gráficos / LCD a color === == Matemáticas == == Menú == * [[LCDMenuLib]] - Una librería con la que puedes generar un menú basado en el modelo de conjunto anidado con múltiples capas. * [[MD_Menu]] - Una librería para mostrar y administrar menús en pantallas con hasta 2 líneas. == Control de movimiento == == Controladores de motor == == Robotica == == Control de poder == == Procesamiento de señales == == Programadores y pseudo sistemas operativos == == Sensores == == Almacenamiento de memoria == [[SD]] - Para la interacción con tarjetas SD (Secure Digital) y la manipulación de archivos (ficheros) y directorios (carpetas) que hay en ellas. == Instrumentos de cuerda == == Pruebas, utilidades y ahorro de energia == == Sincronización == * [[Time]] - reloj de software en tiempo real. * [[Metro]] - implementación de eventos temporizados recurrentes, como LED parpadeantes o control del servomotor. * [[Chronos]] - Fácilmente manipular los tiempos de fecha para realizar la programación, calendarios de configuración y encontrar puntos en el tiempo que sean de su interés. * [[RTC]] - reloj físico externo o por software. == Vea también == == Referencias externas == * [http://arduino.cc/en/Reference/Libraries Bibliotecas oficiales de Arduino] * [https://playground.arduino.cc/Main/LibraryList Libreries for Arduino] * [https://www.arduinolibraries.info/libraries Arduino libraries] [[Category:Librerias]] o5r892yhr2mwsps738pe0rc857ww443 0 454 4006 4005 2019-05-21T00:09:42Z Kike GL 2 /* Puertos serie */ wikitext text/x-wiki == Descripción == El MEGA 2560 está diseñado para proyectos más complejos. Con 54 pines de E/S digitales, 16 entradas analógicas y un espacio más grande para su [[boceto]], es la placa recomendada para impresoras 3D y proyectos de robótica. Esto le da a sus proyectos un montón de espacio y oportunidades. Basado en el microcontrolador ATmega2560. Tiene 54 pines de entrada/salida digital, de los cuales 15 se pueden usar como salidas PWM, 16 entradas analógicas, 4 UARTs (puertos serie de hardware), un oscilador de cristal de 16 MHz, una conexión USB, una clavija de alimentación, pines ICSP y un botón de reinicio. == Características == {|class="wikitable" |+Especificaciones técnicas !Parámetro!!Valor |- |uC||ATmega2560 |- |Bus||8 bits |- |Velocidad||16Mhz |- |Memoria [[flash]]||256KB (8KB para arranque) |- |Memoria [[SRAM]]||8KB |- |Memoria [[EEPROM]]||4KB |- |Alimentación||5V |- |Entrada||7~12V |- |Entrada limite||6~20V |- |Pines digitales||54 (15 PWM de 8 bits) |- |Pines analógicos||16 |- |Corriente por pines||20 mA |- |[[LED_BUILTIN]]||13 |} == Puertos serie == {| class="wikitable" |+Puertos serie físicos |- ! Texto de encabezado !! Rx !! Tx |- | Serie || 0 || 1 |- | Serie1 || 19 || 18 |- | Serie2 || 17 || 16 |- | Serie3 || 15 || 14 |} Los pines Rx y Tx se pueden usar para comunicaciones serie asíncronas. Estos pines también están conectados internamente a través de resistencias de 1K al chip USB, de modo que los datos de la interfaz USB se pueden enviar/recibir a los pines 0 y 1. == Bus I2C == Un protocolo '''Inter Integrated Circuit''' (también llamado TWI) usa una línea de reloj (SCL) junto con una línea de datos (SDA) para transferir información. Reloj serie ;SCL (Serial Clock Line): La línea de reloj. Pin 21. Usada por I2C para indicar datos está lista en la línea de datos. ;SDA (Serial Data Line): La línea de datos (bidireccional). Pin 20. Usada para datos seriales. {{Nota|Para saber mas consulta la libreria [[Wire]].}} == Polifusible == El MEGA 2560 tiene un polyfuse reiniciable que protege los puertos USB de su computadora de cortocircuitos y sobrecargas. Aunque la mayoría de las computadoras brindan su propia protección interna, el fusible brinda una capa adicional de protección. Si se aplican más de 500 mA al puerto USB, el fusible romperá automáticamente la conexión hasta que se elimine el cortocircuito o la sobrecarga. == Vea también == * [[UNO]] * [[NANO]] == Referecias == [[Category:Placas]] nmyv640nnfmhfhxydafmpbiyy73i7u8 0 419 3226 2019-05-03T22:55:33Z Kike GL 2 Página creada con «== Descripción == La librería [https://github.com/adafruit/Adafruit_MQTT_Library MQTT] de Adafruit... == Placas aplicables == == Sintaxis == <pre> </pre> == Métodos =...» wikitext text/x-wiki == Descripción == La librería [https://github.com/adafruit/Adafruit_MQTT_Library MQTT] de Adafruit... == Placas aplicables == == Sintaxis == <pre> </pre> == Métodos == == Comentarios == == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] [[Category:Librerias]] 5gl3tdi226uyb0agpkk9byl6qmx12os 0 255 3739 1031 2019-05-06T22:09:44Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Sensores</categorytree> == Referencias == [[Category:Sensores]] phrz68vyt00mk72xrwh41yn8g07pld8 0 234 3744 1004 2019-05-06T22:12:11Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 235 3745 1005 2019-05-06T22:12:30Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 420 4455 4454 2019-06-16T18:20:57Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == La librería [https://github.com/ChuckBell/MySQL_Connector_Arduino MySQL] de Charles Bell se puede usar para conectar su proyecto Arduino directamente a un servidor MySQL sin usar una computadora intermedia o un servicio web o basado en la nube. Tener acceso directo a un servidor de base de datos significa que puede almacenar los datos adquiridos de su proyecto, así como verificar los valores almacenados en las tablas en el servidor. Esto también significa que puede configurar su propio servidor MySQL local para almacenar sus datos y eliminar la necesidad de conectividad a Internet. Si eso no es un problema, aún puede conectarse y almacenar datos en un servidor MySQL a través de su red, Internet o incluso en la nube. == Placas aplicables == == Sintaxis == <pre> #include <Ethernet.h> #include <MySQL_Connection.h> #include <MySQL_Cursor.h> </pre> == Métodos == {| class="wikitable" |+Metodos de MySQL |- ! Método !! Descripción |- | connect() || Conecta con la base de datos |- | execute() || Ejecuta una consulta |- | show_results() || Muestra el resultado de la consulta |- | field_struct() || Muestra la estructura de la tabla |} == Comentarios == == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> #include <Ethernet.h> #include <MySQL_Connection.h> #include <MySQL_Cursor.h> byte mac_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; IPAddress server_addr(192.168,1,35); //IP del servidor MySQL char usuario[] = "root"; //usuario MySQL char clave[] = ""; //Clave usuario MySQL //Consulta char query[] = "SELECT campo1 FROM base.tabla WHERE campo2 = 'Lima'"; EthernetClient client; MySQL_Connection conn((Client *)&client); //Crea instancia de conexion MySQL_Cursor cur = MySQL_Cursor(&conn); void setup() { Serial.begin(115200); Ethernet.begin(mac_addr); Serial.println("Conectando..."); if (conn.connect(server_addr, 3306, usuario, clave)) { delay(1000); }else{ Serial.println("Fallo la conexion."); } } void loop() { row_values *row = NULL; long head_count = 0; delay(1000); Serial.println("1) Demonstrating using a cursor dynamically allocated."); // Initiate the query class instance MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn); //Ejecutando la consulta cur_mem->execute(query); //Opcionalmente se extraen los nombres de columna column_names *columns = cur_mem->get_columns(); // Read the row (we are only expecting the one) do { row = cur_mem->get_next_row(); if (row != NULL) { head_count = atol(row->values[0]); } } while (row != NULL); //Borrando el cursor de memoria delete cur_mem; // Show the result Serial.print(" NYC pop = "); Serial.println(head_count); delay(500); Serial.println("2) Demonstrating using a local, global cursor."); // Execute the query cur.execute(query); // Fetch the columns (required) but we don't use them. cur.get_columns(); // Read the row (we are only expecting the one) do { row = cur.get_next_row(); if (row != NULL) { head_count = atol(row->values[0]); } } while (row != NULL); // Now we close the cursor to free any memory cur.close(); // Show the result but this time do some math on it Serial.print(" NYC pop = "); Serial.println(head_count); Serial.print(" NYC pop increased by 12 = "); Serial.println(head_count+12); } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] [[Category:Librerias]] pws6v29j7i4r30l1nn0aqaf980qblcw 0 376 4636 4161 2019-07-04T16:31:28Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == El Arduino Nano es una placa pequeña, compacta y fácil de usar basado en el ATmega328P (como [[UNO]]). Solo le falta la clavija de alimentación VCC, pero tiene el pin VIN y funciona con un cable USB Mini-B en lugar de uno estándar. Esta basado en el uC ATmega328P de 8 bits a 16 MHz, perteneciente a la familia AVR de arquitectura RISC, 32 registros de trabajo, 3 temporizadores flexibles, UART serie, convertidos ADC de 14 canales de 10 bits. Encapsulado DIP de 28 pines. == Características == {|class="wikitable" |+Especificaciones técnicas !Parámetro!!Valor |- |uC||ATmega328P |- |Bus||8 bits |- |Velocidad||16 Mhz |- |Memoria [[flash]]||32KB (2KB para arranque) |- |Memoria [[SRAM]]||2KB |- |Memoria [[EEPROM]]||1KB |- |Alimentación||5V |- |Entrada||7~12V |- |Entrada limite||6~20V |- |Pines digitales||14 (6 PWM de 8 bits) |- |Pines analógicos||8 |- |Corriente por pines||40 mA |- |[[LED_BUILTIN]]||13 |} == Interrupciones == Interrupciones externas: 2 y 3. Estos pines se pueden configurar para activar una interrupción en un valor bajo, un flanco ascendente (RISING) o descendente (FALLING), o un cambio en el valor (CHANGE). Vea la función [[attachInterrupt()]] para más detalles. == Pines digitales == * Existen 14 pines digitales (0~13) que pueden ser configurados como entrada o salida digital. * No debes meter o sacar mas de 40 mA en cada una. * 6 de ellos están marcados con '''~''' y pueden ser usados como [[analogWrite()|PWM]]. 3, 5, 6, 9, 10 y 11. * Deben ser previamente configurados con [[pinMode()]]. == Pines analógicos == * Los pines marcados A0~A7 se usan para hacer lecturas "analógicas" que son codificadas via un ADC. No es necesario usar [[pinMode()]]. * Cada entrada analógica tiene una resolución de 10 bits. Usando la función [[analogRead()]] se obtiene lectura entre 0 (para 0V) y 1023 (para 5V). El rango puede alterarse fácilmente usando la función [[map()]] y/o suministrando un voltaje diferente al pin AREF. * Aquí puede poner alguna fuente de voltaje (de 0 a 5 V) como una "referencia de voltaje" precisa para las llamadas a la función [[analogRead()]]. * Los pines analógicos A0~A5 también pueden usarse para lectura/escritura digital. Para este propósito, puede referirse a ellos como pines 14~19. Los pines analógicos A6 y A7 no pueden ser usados como digitales. == LEDs == * Un LED power marcado como ON. * Tiene un LED incorporado en el pin digital 13 denominado [[LED_BUILTIN]]. Cuando el pin 13 esta en HIGH prende. * Dos LEDs de transmision serie Tx/Rx. Los LED de Tx y Rx en la placa parpadearán cuando los datos se estén transmitiendo a través del chip FTDI y la conexión USB a la computadora, pero no para la comunicación en serie en los pines 0 y 1. == Botones == * Tiene un botón reset. * Adicionalmente tiene un pin RST que con un LOW reiniciar el microcontrolador. Normalmente se usa para agregar un botón de reinicio con los modulos que bloquean el botón incorporado. == ICSP == * Exiten un conectores ICSP conectado al ATmega328P. * Se usa para programar el uC ATmega328P principal (el más común) o el procesador de interfaz USB ATmega16U2 (solo si es necesario). * El sistema ICSP usa [[SPI]] con un protocolo integrado en los chips. {|class="wikitable" !pin!!Descripcion |- |1||MISO |- |2||5V |- |3||SCK |- |4||MOSI |- |5||RST |- |6||GND |} {{Nota|La programación también se realiza normalmente usando la interfaz serie asíncrona (pines D0 / D1) y un programa de gestor de arranque instalado.}} == Puerto serie == Los pines 0 (Rx) y 1 (Tx) se pueden usar para comunicaciones serie asíncronas. Estos pines también están conectados internamente a través de resistencias de 1K al chip USB, de modo que los datos de la interfaz USB se pueden enviar/recibir a los pines 0 y 1. Un FTDI FT232RL en la placa canaliza esta comunicación serie a través de USB y los controladores FTDI (incluidos con el software Arduino) proporcionan un puerto de comunicaciones virtual con una computadora. {{Nota|La libreria [[SoftwareSerial]] permite la comunicación en serie por cualquiera de los pines digitales del Nano.}} == Bus I2C == Un protocolo '''Inter Integrated Circuit''' (también llamado TWI) usa una línea de reloj (SCL) junto con una línea de datos (SDA) para transferir información. Reloj serie ;SCL (Serial Clock Line): La línea de reloj. Pin A5. Usada por I2C para indicar datos está lista en la línea de datos. ;SDA (Serial Data Line): La línea de datos (bidireccional). Pin A4. Usada para datos seriales. {{Nota|Para saber mas consulta la libreria [[Wire]].}} == Bus SPI == Un protocolo '''Serial Peripheral Interface''' usa una línea de reloj (SCK) junto con datos de maestro a esclavo (MOSI) y esclavo a maestro (MISO) para transferir información. También se usa comúnmente una línea de selección de esclavos (SS) para seleccionar un esclavo de entre múltiples. ;SCK (Serial Clock): Pin 13. Una línea de reloj generada por el maestro para "reloj" de datos al esclavo. ;MOSI (Master Out, Slave In): Pin 12. Los datos van del maestro al esclavo. ;MISO (Master In, Slave Out): Pin 11. Los datos van del esclavo al maestro. ;SS (Slave Select): Pin 10. Usado para seleccionar un esclavo. Típicamente se baja para estar activo. {{Nota|Revisa la libreria [[SPI]] para saber como usarlo.}} == Rangos máximos == Los pines IO tienen una calificación máxima absoluta de 40 mA por pin. Sin embargo, en la práctica, debe diseñar para que una clasificación de 20 mA sea segura. Además, los siguientes grupos de pines no deben hundirse más de 100 mA (cada grupo): * Pines digitales del D0 a D4 * Pines digitales del D5 al D13 * Pines analógicos del A0 a A7 {|class="wikitable col1cen" |+Banco de puertos ATmega328p !Puerto!!2⁷!!2⁶!!2⁵!!2⁴!!2³!!2²!!2¹!!2⁰ |- |B||||||D13||D12||D11||D10||D9||D8 |- |C||A7||A6||A5||A4||A3||A2||A1||A0 |- |D||D7||D6||D5||D4||D3||D2||D1||D0 |- !Puerto!!128!!64!!32!!16!!8!!4!!2!!1 |} Además de eso, todo el chip del procesador tiene una calificación máxima de consumo de corriente de 200 mA. Estas cifras generalmente se refieren a los pines en el modo de salida (el modo de entrada no consumirá mucha potencia). De modo que puede ver que, configurados como salidas, solo podría tener 10 pines que suministran 20 mA cada uno (para evitar exceder el máximo del chip) e incluso entonces tendrían que extenderse para que no consuma más de 100 mA de un grupo mencionado anteriormente. == Resistencias limitadoras de corriente == * Como regla general, si conecta un LED a un pin digital configurado como salida, querrá algo así como una resistencia de 330 ohm en serie con el diodo. * Esto se debe a que desea extraer algo así como 10 mA de corriente, con una caída de voltaje de 3V3 (el diodo cae 1V7, por lo que la resistencia suelta los otros 3V3 de un suministro de 5V). Usando la ley de Ohms, 3.3 / 0.010 = 330 ohmios. {{Nota|Incluso una resistencia de 1K proporciona una salida de LED razonablemente brillante, y solo consume alrededor de 3.3 mA.}} == Fuente de alimentación == La placa se puede alimentar desde el conector USB para probar mientras está conectado a una computadora o con una fuente de 5V. Si usa un suministro externo, se recomienda un rango de voltaje entre 7~12V (por ejemplo, se podría usar una batería de 9V) por el pin VIN. Tenga en cuenta que cuanto mayor sea el voltaje, más trabajo debe hacer el regulador de voltaje para "tirar" el exceso de voltaje, de modo que con un suministro de 12V o mas y alimentando bastantes "periféricos", es probable que el regulador de voltaje se caliente. Por otro lado, el circuito interno está diseñado para cambiar de USB a externo si el suministro externo excede 6V6, por lo que el suministro de mucho menos de 7V probablemente no funcionará correctamente. == Polifusible == == Vea también == * [[UNO]] * [[MINI]] * [[MICRO]] * [[MEGA]] * [[DUE]] * [[101]] * [[LEONARDO]] * [[MKR1000]] == Referencias externas == * [https://www.arduino.cc/en/uploads/Main/Arduino_Nano-Rev3.2-SCH.pdf Esquema] * [http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_Datasheet.pdf Datasheat 328P] - Microchip * [http://www.gammon.com.au/uno Arduino UNO] - Nick Gammon * [http://manueldelgadocrespo.blogspot.com/p/modelos_29.html Modelos de Arduino] - Manuel Delgado * [https://descubrearduino.com/elegir-la-placa-arduino-adecuada-para-tu-proyecto-una-introduccion/ Que modelo comprar] - Descubre Arduino * [https://aprendiendoarduino.wordpress.com/2016/11/06/hw-arduino-a-fondo/ Arduino a fondo] - Enrique Crespo * [http://diymakers.es/guia-arduino/ Guia Arduino] - Diy Makers [[Category:Placas]] 66vgmrkzzc0ht4mvzrxdr26jrzugg27 0 487 4891 4890 2019-09-18T17:03:21Z Kike GL 2 /* Ejemplo 1 */ wikitext text/x-wiki == Descripción == NodeMCU integra el ESP8266 con un modulo WiFi (ESP-12E). Este módulo tiene, además del microprocesador (Tensilica), una antena PCB, un LED conectado al GPIO2 y una memoria flash de 16 Mbit (= 4 MB). Es un proyecto de código abierto, el firmware y el diseño hardware esta disponible en GitHub. Cuando fue presentada, no existía la integración de ESP8266 con el entorno de [[IDE]] de Arduino. No usaba un lenguaje compilado sino uno interpretado llamado LUA. Como todas las placas que usan ESP8266, se les puede cargar cualquier firmware. Puede usarse desde el propio de NodeMCU con lenguaje LUA, a MicroPython. También se puede usar como una placa de Arduino, donde nosotros hacemos el firmware desde cero. == Caracteristicas == {|class="wikitable" |+Especificaciones técnicas !Parámetro!!Valor |- |uC||Tensilica ESP8266 |- |Bus||32 bits |- |Velocidad||80-160 MHz |- |Memoria [[flash]]||4MB (512KB normal) |- |Memoria [[SRAM]]||2KB |- |Memoria [[EEPROM]]||1KB |- |Alimentación||5V (USB) |- |Entrada||3V3 |- |Pines digitales||13 (6 PWM de 8 bits) |- |Pines analógicos||1 (A0) de ADC de 10 bits |- |Corriente por pines||12 mA |- |WiFi||2.4 GHz, 802.11, max 5 simultaneas |} == Pines == {|class="wikitable" |+Especificaciones técnicas !Pin!!GPIO!!Nombre |- |D0||16||Digital 0 (LED) |- |D1||5||Digital 1 |- |D2||4||Digital 2 |- |D3||0||Digital 3 |- |D4||2||Digital 4 (LED ESP-12E) |- |D5||14||Digital 5 |- |D6||12||Digital 6 |- |D7||13||Digital 7 |- |D8||15||Digital 8 |- |D9||3||Digital 9 |- |D10||1||Digital 10 |- |VIN||+5V (USB) |- |3V||+3.3V |- |G||GND |} == Pines digitales == * Tenemos 11 pines de entrada/salida digital. Pero no te recomiendo usar los pines 6~11 porque están conectados a la memoria flash. == PWM == * ESP8266 tiene cuatro (4) salidas PWM. * El rango de frecuencia es de 100 Hz a 1 KHz. == Pines analogicos == * El ESP8266 tiene un solo puerto análogo (A0) con ADC de 10 bits. == LEDs == * LED1: D4 y pertenece al ESP-12E. * LED2: D0 es de la propia placa, parpadea durante la carga de un programa == Botones == * Tiene dos botones: RST (reset) y FLASH, que permite activar el modo de carga de firmware. * Si usamos el [[IDE]] Arduino no son necesarios. ;RST:Reset, reinicia la placa pero no borra código. ;FLASH:Dejar estado de ejecución y pasar a estado de recibir código. == Puerto serie == * El puerto serie esta en pin 1 (Rx) y pin 3 (Tx), están protegidos con resistencias de 470 ohms. ;Rx0: GPIO 3 ;Tx0: GPIO 1 ;Rx1: GPIO 2 ;Tx1: GPIO 8 == I2c bus == * Soporta i2c maestro y esclavo. * Frecuencia maxima 100 kHz ;SCL: GPIO 14 ;SDA: GPIO 2 == Sintaxis == <pre> WiFi.mode(WIFI_STA); //Modo cliente WiFi WiFi.begin(ssid, clave); </pre> == Ventajas == * Bajo precio, mucho menor que Arduino * WiFi incorporado == Desventajas == * No muy intuitivo las referencias entre numero de pin y puerto GPIO. * Alimantacion de 3.3 V == Ejemplo 1 == <syntaxhighlight lang="c++"> #define LED_BUILTIN 2 #define BUTTON_BUILTIN 0 void setup() { pinMode(2, OUTPUT); pinMode(0, INPUT); } void loop() { int estado = digitalRead(0); digitalWrite(2, estado); } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup() { pinMode(D2, OUTPUT); } void loop() { //El LED tiene una resistencia pull-up, por eso se enciende con LOW digitalWrite(D2, LOW); delay(1000); //Esperar un segundo //Apagar el LED digitalWrite(D2, HIGH); delay(1000); //Esperar un segundo } </syntaxhighlight> == Vea tambien == * [[UNO]] * [[NANO]] * [[MEGA]] == Referencias externas == * [https://www.espressif.com/sites/default/files/documentation/0a-esp8266ex_datasheet_en.pdf ESP8266 datasheat] - Espressif [[Category:Placas]] 7sfsvbtutnterpgtdbklw79v96caclc 0 491 4938 4937 2019-09-21T14:56:02Z Kike GL 2 /* OPC server for Arduino */ wikitext text/x-wiki == Descripción == OLE for Process Control (OPC), que significa Enlace e Incrustación de Objetos (OLE) para Control de Procesos, es el nombre original para una especificación de estándares desarrollada en 1996 por un grupo de trabajo de la industria de automatización industrial. El estándar especifica la comunicación de datos de planta en tiempo real entre dispositivos de control de diferentes fabricantes. == OPC server for Arduino == Es un servidor OPC fácil de usar y configurar que le permite conectar su Arduino con cualquier compilador OPC [[SCADA]]. Simplemente use la libreria [https://github.com/SoftwareTools4Makers/OPC OPC.h] en su [[boceto]] Arduino, publique sus artículos y proporcione datos para cada artículo que publicó en tiempo real. Puede recuperar/enviar información desde/hacia su software [[SCADA]] HMI para crear aplicaciones industriales. == Ejemplo == <pre> #include <OPC.h> OPCSerial aOPCSerial; //Instancia el objeto const byte analogPin = 3; //create a callback function for the OPCItem int callback(const char *itemID, const opcOperation opcOP, const int value){ return analogRead(analogPin); } void setup() { Serial.begin(9600); aOPCSerial.setup(); //Inicializa objeto aOPCSerial.addItem("A0",opc_read, opc_int, callback); } void loop() { //OPC process commands aOPCSerial.processOPCCommands(); } </pre> == Vea también == * [[SCADA]] * [[PLC]] * [[PIC]] == Referencias externas == * [https://www.st4makers.com/ OPC server for Arduino] 56u1y88iov49zntwj9g47jb2c1ytnvn 0 492 4958 4957 2019-09-23T23:03:36Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripcion == Existen dos tipos de interrupciones externas: * INT, interrupciones de harware externo * PCINT, interrupciones Pin Change, que actual a nivel de bancos completos. == Sintaxis == <pre> PCICR; PCMSK0; PCIFR; ISP(PCINT0_vect) //D8 a D13 ISP(PCINT1_vect) //A0 a A5 ISP(PCINT2_vect) //D0 a D7 </pre> == Puertos INT == {|class="wikitable" |+Arduino [[UNO]] y [[NANO]] |- !Pin!!Port!!INT |- |2||PD2||INT0 |- |3||PD3||INT2 |} {|class="wikitable" |+Arduino [[MEGA]] |- !Pin!!Port!!INT |- |6||PE4||INT4 |- |7||PE5||INT5 |- |43||PD0||INT0 |- |44||PD1||INT1 |- |45||PD3||INT2 |- |46||PD6||INT3 |} == Puertos PCINT == {|class="wikitable" |+Arduino [[UNO]] y [[NANO]] |- !Pin!!Port!!PCINT!!Pin!!Port!!PCINT!!Pin!!Port!!PCINT |- |2||PD2||PCINT18||8||PB0||PCINT0||A0||PC0||PCINT8 |- |3||PD3||PCINT19||9||PB1||PCINT1||A1||PC1||PCINT9 |- |4||PD4||PCINT20||10||PB2||PCINT2||A2||PC2||PCINT10 |- |5||PD5||PCINT21||11||PB3||PCINT3||A3||PC3||PCINT11 |- |6||PD6||PCINT22||12||PB4||PCINT4||A4||PC4||PCINT12 |- |7||PD7||PCINT23||13||PB5||PCINT5||A5||PC5||PCINT13 |} {|class="wikitable" |+Arduino [[UNO]] y [[NANO]] |- !Pin!!Port!!PCINT!!Pin!!Port!!PCINT!!Pin!!Port!!PCINT |- |10||PB4||PCINT4||SS||PCINT0||PB0||A8||PK0||PCINT16 |- |11||PD7||PCINT5||SCK||PCINT1||PB1||A9||PK1||PCINT17 |- |12||PD7||PCINT6||MOSI||PCINT2||PB2||A10||PK2||PCINT18 |- |13||PD7||PCINT7||MISO||PCINT3||PB3||A11||PK3||PCINT19 |- |14||PD7||PCINT10||-||-||-||A12||PK4||PCINT20 |- |15||PD7||PCINT9||-||-||-||A13||PK5||PCINT21 |- | -||-||-||-||-||-||A14||PK6||PCINT22 |- | -||-||-||-||-||-||A15||PK7||PCINT23 |} == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> // Activar PCINT en un PIN void pciSetup(byte pin){ *digitalPinToPCMSK(pin) |= bit (digitalPinToPCMSKbit(pin)); //activar pin en PCMSK PCIFR |= bit (digitalPinToPCICRbit(pin)); //limpiar flag de la interrupcion en PCIFR PCICR |= bit (digitalPinToPCICRbit(pin)); //activar interrupcion para el grupo en PCICR } // Definir ISR para cada puerto ISR(PCINT0_vect) { //gestionar para PCINT para D8 a D13 } ISR(PCINT1_vect){ //gestionar PCINT para A0 a A5 } ISR(PCINT2_vect){ //gestionar PCINT para D0 a D7 } void setup(){ //Activar las PCINT para distintos pins pciSetup(7); pciSetup(8); pciSetup(9); pciSetup(A0); } void loop(){ //Nada } </syntaxhighlight> == Vea tambien == * [[INT]] == Referencias externas == * [https://www.luisllamas.es/interrupciones-en-todos-los-pines-de-arduino-con-pcint/ PCINT] - Luis Llamas 8bi45n42fzwhr858tktyiit6orwwvha 0 421 3228 2019-05-03T23:04:05Z Kike GL 2 Página creada con «== Descripción == La librería [https://github.com/phpoc/arduino PHPoC] de Sollae Systems... == Placas aplicables == == Sintaxis == <pre> </pre> == Métodos == == Come...» wikitext text/x-wiki == Descripción == La librería [https://github.com/phpoc/arduino PHPoC] de Sollae Systems... == Placas aplicables == == Sintaxis == <pre> </pre> == Métodos == == Comentarios == == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] * [http://www.phpoc.com/ PHPoC] - Sollae Systems [[Category:Librerias]] m24x947nspdx9w7kmem2n74iqm9z4ql 0 136 4467 4466 2019-06-24T22:31:48Z Kike GL 2 /* Ejemplo 1 */ wikitext text/x-wiki == Descripción == Es la constante '''Pi''' (π), también conocida como la circunferencia de un círculo "base".<br> Su valor se aproxima a 3.14159265358979323846; sin embargo, para efectos de un programa de Arduino, este valor acaba siendo truncado según la limitación de un [[double]] o [[float]]. == Sintaxis == <pre> PI HALF_PI TWO_PI </pre> == Advertencias == * Nota que '''PI''', '''HALF_PI''' y '''TWO_PI''' se debe escribir en mayusculas. == Ejemplo 1 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); Serial.println(sin(0), 3); //0.000 Serial.println(sin(HALF_PI/2), 3); //0.707 Serial.println(sin(HALF_PI), 3); //1.000 Serial.println(sin(PI), 3); //0.000 Serial.println(sin(PI+HALF_PI), 3); //-1.000 Serial.println(sin(TWO_PI), 3);} //0.000 void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); } void loop(){ for (float n=0; n<TWO_PI; n+=0.01){ Serial.println(sin(n)); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Palabras reservadas</categorytree> == Referencias externas == [[Category:Palabras reservadas]] [[Category:Funciones trigonometricas]] tcvkz3f4ytukpb88zafsrye26ljuuai 0 384 4933 4436 2019-09-21T14:32:22Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Peripheral Interface Controller (PIC) o controlador de interfaz periférico son una familia de microcontroladores (uC) tipo RISC fabricados por '''Microchip Technology Inc''' y basado en el PIC1650, originalmente desarrollado por la división de microelectrónica de General Instrument. == Características == Los PIC actuales vienen con una amplia gama de mejoras hardware incorporadas: * Núcleos de CPU de 8/16 bits con Arquitectura Harvard modificada * Memoria Flash y ROM disponible desde 256 bytes a 256 kilobytes * Memoria EEPROM interna con duración de hasta un millón de ciclos de lectura/escritura * Puertos de entrada/salida (típicamente 0 a 5.5 voltios) * Temporizadores de 8/16/32 bits * Tecnología Nanowatt para modos de control de energía * Periféricos serie síncronos y asíncronos: USART, AUSART, EUSART * Conversores analógico/digital de 8-10-12 bits * Comparadores de tensión * Módulos de captura y comparación PWM * Controladores LCD * Periférico MSSP para comunicaciones I²C, SPI, y I²S * Periféricos de control de motores * Soporte de interfaz USB * Soporte de controladores: Ethernet; CAN; LIN; Irda. == Programación == Para transferir el código de un ordenador al PIC normalmente se usa un dispositivo llamado programador. La mayoría de PIC que Microchip distribuye hoy en día incorporan ICSP (In Circuit Serial Programming, programación serie incorporada) o LVP (Low Voltage Programming, programación a bajo voltaje), lo que permite programar el PIC directamente en el circuito destino. Para la ICSP se usan los pines RB6 y RB7 (En algunos modelos pueden usarse otros pines como el GP0 y GP1 o el RA0 y RA1) como reloj y datos y el MCLR para activar el modo programación aplicando un voltaje de 13 voltios. Existen muchos programadores de PIC, desde los más simples que dejan al software los detalles de comunicaciones, a los más complejos, que pueden verificar el dispositivo a diversas tensiones de alimentación e implementan en hardware casi todas las funcionalidades. Muchos de estos programadores complejos incluyen ellos mismos PIC preprogramados como interfaz para enviar las órdenes al PIC que se desea programar. Uno de los programadores más simples es el TE20, que utiliza la línea TX del puerto RS-232 como alimentación y las líneas DTR y CTS para mandar o recibir datos cuando el microcontrolador está en modo programación. El software de programación puede ser el ICprog, muy común entre la gente que utiliza este tipo de microcontroladores. Entornos de programación basados en intérpretes BASIC ponen al alcance de cualquiera proyectos que parecieran ser ambiciosos. Se pueden obtener directamente de Microchip muchos programadores/depuradores (octubre de 2005): * PICStart Plus (puerto serie y USB) * Promate II (puerto serie) * MPLAB PM3 (puerto serie y USB) * ICD2 (puerto serie y USB) * ICD3 (USB) * PICKit 1 (USB) * IC-Prog 1.06B * PICAT 1.25 (puerto USB2.0 para PIC y Atmel) * WinPic 800 (puerto paralelo, serie y USB) * PICKit 2 (USB) * PICKit 3 (USB) * Terusb1.0 * Eclipse (PIC y AVR. USB) * MasterProg (USB) == Vea también == * [[PLC]] * [[AVR]] * [[FPGA]] * [[SCADA]] == Referencias == [[Category:Placas]] mds8sptvbi0bpfo9gmpinmqlnjqnqot 0 417 3266 3265 2019-05-04T14:53:03Z Kike GL 2 /* Métodos */ wikitext text/x-wiki == Descripción == Un controlador Proporcional Integral Derivativo PID calcula un valor de "error" como la diferencia entre una entrada '''Input''' medida y un punto de referencia '''setPoint''' deseado. El controlador intenta minimizar el error ajustando la salida '''Output'''. La librería PID_v1.h requiere de tres paramentos kp, ki y kd. == Placas aplicables == == Sintaxis == <pre> PID(&Input, &Output, &Setpoint, Kp, Ki, Kd, Direction); </pre> == Parámetros == ;Input: ;&Output: ;&Setpoint: ;Kp: ;Ki: ;Kd: ;Direction: == Métodos == Aunque un controlador PID está diseñado para funcionar con una salida analógica, es posible conectarlo a una salida didital, como un relé. En este caso se debe definir un ciclo de trabajo y lo que hace el PID en establecer la proporcion entre HIGH y LOW mediante los metodos: SetSampleTime(ciclo) y SetAoutputLimits(min,max) {| class="wikitable" |+Métodos libreria PID |- !Método!!Descripción |- |Computer()||Calcula una nueva salida cada ciclo. Responde verdadero si se calculo. |- |SetMode(modo)||Especifica si PID esta AUTOMATIC o MANUAL |- |SetOutputLimits(min,max)||Especifica el rango de salida |- |SetSampleTime(ciclo)||Determina el ciclo, predetreminado es 200 ms |- |SetTunings(kp,ki,kd)||Permite reajustar los parámetros iniciales de reaccion del PID |- |SetControlDirection(dirección)||Especifica si la salida es DIRECT o REVERSE. |} == Comentarios == == Advertencias == == Ejemplo 1 == Lectura de entrada analogica A0 para controlar salida analogica PWM D3 <syntaxhighlight lang="c++"> #include <PID_v1.h> float Input, Output, Setpoint; PID miPID(&Input, &Output, &Setpoint, 2, 5, 1, DIRECT); void setup(){ Setpoint = 100; miPID.SetMode(AUTOMATIC); } void loop(){ Input = analogRead(0); miPID.Compute(); //Señal PWM analogWrite(3,Output); } </syntaxhighlight> == Ejemplo 2 == Lectura de entrada analogica A0 para controlar salida digital D6 con un ciclo de trabajo de 5 segundos. Por eso se establece la salida del PID entre 0 y 5 segundos de modo que el PID ajustara el % de tiempo que el rele esta activado durante cada ciclo. <syntaxhighlight lang="c++"> #include <PID_v1.h> float Input, Output, Setpoint; PID miPID(&Input, &Output, &Setpoint, 2, 5, 1, DIRECT); int ciclo = 5000; unsigned long StartTime, now; void setup(){ pinMode(6, OUTPUT); Setpoint = 100; miPID.SetOutputLimits(0, ciclo); miPID.SetMode(AUTOMATIC); StartTime = millis(); } void loop(){ now = millis(); if (now - StartTime > ciclo){ StartTime += ciclo; } Input = analogRead(0); miPID.Compute(); if (Output > now - StartTime){ digitalWrite(6, HIGH); }else{ digitalWrite(6, LOW); } } </syntaxhighlight> == Ejemplo 3 == Uno de los beneficios de la esta libreria es que se puedes cambiar los parámetros de ajuste (kp, ki, kd) en cualquier momento. Esto puede ser útil si queremos que el PID sea agresivo algunas veces y conservador en otros. <syntaxhighlight lang="c++"> #include <PID_v1.h> float Input, Output, Setpoint; float aggKp=4, aggKi=0.2, aggKd=1; //PID agresivo float consKp=1, consKi=0.05, consKd=0.25; //PID conservador PID miPID(&Input, &Output, &Setpoint, consKp, consKi, consKd, DIRECT); void setup(){ pinMode(3, OUTPUT); Setpoint = 100; miPID.SetMode(AUTOMATIC); } void loop(){ Input = analogRead(0); double gap = abs(Setpoint-Input); if (gap<10){ miPID.SetTunings(consKp, consKi, consKd); }else{ miPID.SetTunings(aggKp, aggKi, aggKd); } miPID.Compute(); //Señal PWM analogWrite(3,Output); } </syntaxhighlight> == Ejemplo 4 == Configurar el PID para usar P_ON_M hacer que la salida se mueva más suavemente cuando el punto de ajuste (Setpoint) está cambiado. Además, puede eliminar el sobrepico en ciertos procesos. Las opciones son: P_ON_M (Proportional ON Measurement) y P-ON_E (Proportional ON Err). <syntaxhighlight lang="c++"> #include <PID_v1.h> float Input, Output, Setpoint; PID miPID(&Input, &Output, &Setpoint, 2, 5, 1, P_ON_M, DIRECT); void setup(){ pinMode(3, OUTPUT); Setpoint = 100; miPID.SetMode(AUTOMATIC); } void loop(){ Input = analogRead(0); miPID.Compute(); //Señal PWM analogWrite(3, Output); } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] [[Category:Librerias]] 3ek4hz2db90tx89pnebxdurfa042mdc 0 383 4928 4435 2019-09-21T14:27:55Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Un Programmable Logic Controller (PLC) o '''controlador lógico programable''', es una computadora usada en la automatización industrial, para automatizar procesos electromecánicos, tales como el control de la maquinaria de la fábrica en líneas de montaje o atracciones mecánicas. El PLC está diseñado para contener múltiples señales de entrada y salida; amplios rangos de temperatura; inmunidad al ruido eléctrico; resistencia a la vibración y al impacto. Los programas para el control de funcionamiento de la máquina se suelen almacenar en baterías, copia de seguridad o en memorias no volátiles. Un PLC es un ejemplo de un sistema de tiempo real, donde los resultados de salida deben ser producidos en respuesta a las condiciones de entrada dentro de un tiempo limitado, de lo contrario no producirá el resultado deseado. {{Nota|Arduino en un pequeño PLC, que no cumple con los estándares industriales. Gracias a su bajo precio (menos a US $ 25) y código abierto, cuenta con una gran comunidad de usuarios y por la gran cantidad de periféricos disponibles, con el se puede hacer cosas mucho mas complejas que un PLC comercial que puede costar hasta US $1000.}} == Historia == Su historia se remonta a finales de la década de 1960, cuando la industria buscó en las nuevas tecnologías electrónicas una solución más eficiente para reemplazar los sistemas de control basados en circuitos eléctricos con relés, interruptores y otros componentes comúnmente usados para el control de los sistemas de lógica combinacional. En 1968 GM Hydramatic (la división de transmisión automática de General Motors) emitió una solicitud de propuestas para un reemplazo electrónico de los sistemas cableados de relés. La propuesta ganadora vino de Bedford Associates. El resultado fue el primer PLC, designado 084 porque era el proyecto de Bedford Associates nº 84.​ Bedford Associates comenzó una nueva empresa dedicada al desarrollo, fabricación, venta y mantenimiento de este nuevo producto: Modicon (MOdular DIgital CONtroler). Una de las personas que trabajaron en ese proyecto fue Dick Morley, quien es considerado como el '''padre''' del PLC.​ La marca Modicon fue vendida en 1977 a Gould Electronics, y posteriormente adquirida por la compañía alemana AEG y luego por la francesa Schneider Electric, el actual propietario. == Ventajas == Dentro de las ventajas que estos equipos poseen se encuentra que, gracias a ellos, es posible ahorrar tiempo en la elaboración de proyectos, pudiendo realizar modificaciones sin costos adicionales. Por otra parte, son de tamaño reducido y mantenimiento de bajo costo, además permiten ahorrar dinero en mano de obra y la posibilidad de controlar más de una máquina con el mismo equipo. * Cumplen normas industriales internacionales * Están probados en ambientes industriales * Se programan en lenguaje de lógica de escalera (esta estandarizado) * También se pueden programar en lenguajes de bloques (pero varias según modelo) * Lenguaje estructurado. Bajo nivel y control de hardware. * Diagrama de estado == Desventajas == Sin embargo, y como sucede en todos los casos, los PLCs, presentan ciertas desventajas como es la necesidad de contar con técnicos calificados específicamente para ocuparse de su buen funcionamiento; incompatibilidad entre marcas y altos precios de licencias. * Son caros (ciento a miles de dolares) * Los periféricos deben ser de la marca y son caros * Requieren licencias para el software de programación * No hay librerías disponibles * Pobre comunidad de usuarios == Marcas comerciales == * [https://w5.siemens.com/cms/mam/industry/automatizacion/simatic-sistemas-de-automatizacion-industrial/plc/pages/plc-siemens-simatic.aspx Siemens] * [https://www.schneider-electric.com.pe/es/product-category/3900-pac%2C-plc-y-otros-controladores/ Schneider] * [https://ab.rockwellautomation.com/lang-selection.html Allen Bradley] * [https://www.abb.es ABB] * [http://www.omron.com Omron] * [http://www.fujielectric.com Fujielectric] * [https://spanish.alibaba.com/g/chinese-plc.html PLC chinos] == Vea también == * [[ArdBox]] * [[PIC]] * [[AVR]] * [[FPGA]] * [[SCADA]] * [[OPC]] == Referencias == * [https://youtu.be/3bwDiIV09yE PLC vs Arduino] * [https://store.arduino.cc/usa/plc-arduino-ardbox-plc-20-i-os-relay-hf PLC Arduino ArdBox 20] - Industrial Shields * [https://industruino.com/ Industrino] * [https://www.controllino.biz/ Controllino] [[Category:Placas]] 3ywe7o6r3hrs9eeu3aodvulebpthy3h 0 199 5220 5219 2020-02-02T05:19:06Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Almacena datos en la memoria [[flash]] (memoria de programa) en lugar de la [[SRAM]]. La palabra clave '''PROGMEM''' es un modificador de variable, debe ser usada solo con los tipos de datos definidos en la biblioteca <pgmspace.h>. Se le dice al compilador poner esta información en la memoria [[flash]], en lugar de en la [[SRAM]], donde normalmente iría. == Sintaxis == PROGMEM es parte de la biblioteca <pgmspace.h> que está disponible solo en la arquitectura AVR. Por lo que primero necesita incluir la biblioteca en la parte superior de su boceto, como esto: <pre> #include <avr/pgmspace.h> const tipo variable[] PROGMEM = {}; //usar este formato const PROGMEM tipo variable[] = {}; //o este formato const tipo PROGMEM variable[] = {}; //NO usar este formato </pre> == Parámetros == ;variable: el nombre de nuesta dato o matriz ;tipo: cualquier tipo de variable [[byte]], [[int]], [[long]], [[float]], etc == Advertencias == * Tenga en cuenta que debido a que '''PROGMEM''' es un modificador de la variable, no hay ninguna regla dura y rápida acerca de donde debe ir, por lo que el compilador de Arduino acepta todas las definiciones de más abajo, que también son sinónimos. Sin embargo los experimentos han indicado que, en varias versiones de Arduino (que tienen que ver con la versión de GCC), '''PROGMEM''' puede trabajar en un lugar y no en otro. * Mientras que PROGMEM podría ser utilizado con una sola variable, realmente sólo vale la pena el trabajo si se tiene un bloque más grande de datos que necesitan ser almacenados, que suele ser más fácil en una matriz, (u otra estructura de datos C más allá de nuestra presente discusión) . El uso de PROGMEM es un procedimiento de dos pasos. Después de obtener los datos en la memoria Flash, que requiere métodos especiales (funciones), también definidas en la biblioteca pgmspace.h leemos de nuevo los datos de la memoria de programa en SRAM, por lo que podemos hacer algo útil con él. == Ejemplo 1 == El ejemplo "tabla de cadenas" siguiente ha sido probado para trabajar con Arduino 13. Las versiones anteriores del IDE pueden funcionar mejor si se incluye PROGMEM después del el nombre de la variable. <syntaxhighlight lang="c++"> #include <avr/pgmspace.h> const PROGMEM uint16_t charSet[] = {65000, 32796, 16843, 10, 11234}; const char signMessage[] PROGMEM = {"YO SOY PREDATOR, COMBATIENTE INVISIBLE. CREADO POR EL DEPARTAMENTO DE LOS ESTADOS UNIDOS"}; unsigned int displayInt; char myChar; void setup() { Serial.begin(115200); while (!Serial); //lee de nuevo un int de 2 bytes for (int k=0; k<5; k++) { displayInt = pgm_read_word_near(charSet + k); Serial.println(displayInt); } Serial.println(); //lee de nuevo un caracter int len = strlen_P(signMessage); for (int k=0; k<len; k++){ myChar = pgm_read_byte_near(signMessage + k); Serial.print(myChar); } Serial.println(); } void loop(){ //Nada. } </syntaxhighlight> == Vea también == * [[variable publica]] * [[variable local]] * [[matriz]] * [[define|#define]] * [[static]] * [[volatile]] * [[const]] * [[Palabras reservadas]] == Referencias == [[Category:Variables]] pg4a9qet11qx6cd4otq3emajt8ahktm 0 392 5181 5180 2020-02-02T03:34:56Z Kike GL 2 wikitext text/x-wiki Estas palabras '''reservadas''' son las que cambian de color en el IDE. * [[HIGH / LOW]] * [[true / false]] * [[INPUT / OUTPUT / INPUT_PULLUP]] * [[CHANGE / FALLING / RISING]] * [[DEC / BIN / HEX / OCT]] * [[PI]] * [[LED_BUILTIN]] * [[static]] * [[const]] * [[volatile]] * [[void]] * [[null]] * [[LSBFIRST / MSNFIRST|MSNFIRST]] * [[LSBFIRST / MSNFIRST|LSBFIRST]] * [[include|#include]] * [[define|#define]] * [[Comentarios]] - <nowiki>(// y /* */)</nowiki> == Vea también == <categorytree mode=all>Palabras reservadas</categorytree> == Referencias externas == * [https://playground.arduino.cc/ArduinoNotebookTraduccion/Appendix7/ Palabras reservadas] [[Category:Palabras reservadas]] rx1oz9qxnfphgcylw70i9th5fylutag 0 236 3746 1006 2019-05-06T22:12:49Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 256 3740 1032 2019-05-06T22:10:05Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Sensores</categorytree> == Referencias == [[Category:Sensores]] phrz68vyt00mk72xrwh41yn8g07pld8 0 391 4794 4793 2019-07-18T16:58:27Z Kike GL 2 /* Vea también */ wikitext text/x-wiki El lenguaje de programación usado por Arduino está basado en Processing es un lenguaje de programación y entorno de desarrollo integrado de código abierto basado en Java, de fácil uso y que sirve como medio para la enseñanza y producción de proyectos multimedia. == AVR-LibC == Para programar un Arduino, el lenguaje estándar es C++, aunque es posible programarlo en otros lenguajes. No es un C++ puro sino que es una adaptación que proveniente de AVR-LibC que provee de una librería de C de alta calidad para usar con GCC en los microcontroladores (uC) AVR de ATmel y muchas funciones específicas para los MCU AVR de ATmel. == Vea también == <categorytree mode=all>Arduino</categorytree> == Referencias == [[Category:Arduino]] 51k16kqfb65ogtapb2pc8ov30g2vcpz 0 221 4968 4965 2019-09-26T16:09:23Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki La mayoría de los puertos de los uC son multipropósito, es decir, en función de su configuración se comportan de una forma u otra. El ATmega 328p como cualquier otro uC tiene registros para cada puerto donde define si sera usado como entrada o salida. ATmega 328p tiene 3 bancos o grupos de puertos: B (D8~D13), C (A0~A5) y D (D0~D7), es decir a B y C le faltan puertos debido a que no se dispone de pines suficientes al ser ATmega 328p un DIP-28 (en comparación del tradicional DIP-40 de la mayoría de uC). {| class="wikitable" !Banco!!2⁷!!2⁶!!2⁵!!2⁴!!2³!!2²!!2¹!!2⁰ |- |B||-||-||D13||D12||D11||D10||D9||D8 |- |C||-||-||A5||A4||A3||A2||A1||A0 |- |D||D7||D6||D5||D4||D3||D2||D1||D0 |- !Valor!!128!!64!!32!!16!!8!!4!!2!!1 |} ATmega 328p tiene 3 registro de 8 bits con los que administra estos 3 bancos: * DDRx, determina si el banco '''x''' sera entrada (0) o salida (1). * PORTx, determina si el banco '''x''' estara en nivel HIGH o LOW. También define Pull-up si es fuera una entrada. * PINx, permite leer estado del banco '''x''' (solo lectura). == Registros == Antes de meterme de lleno a explicarte los registros, quiero que primero veamos para que podría servir este esfuerzo. Ventajas de usar registros: * Cada instrucción máquina necesita un ciclo de reloj a 16 MHz. Las funciones [[digitalRead()]] y [[digitalWrite()]] se componen cada una de ellas de varias instrucciones máquina, lo que puede influir negativamente en aplicaciones muy dependientes del tiempo. El Registro '''PORTx''' puede hacer el mismo trabajo en muchos menos ciclos de reloj. * Si necesitas cambiar de estado muchos pines en lugar de hacer un loop [[for]] que tomara mucho tiempo puedes echar mano directamente al registro y establecer varios pines de una sola vez. * Si estas al limite de memoria [[flash]], puedes usar este truco para hacer que tu código use menos bytes de programación. Desventajas de usar registros: * El código no es fácil de entender para novatos. * Es mucho mas fácil que cometas errores de difícil depuración. Por ejemplo con DDRD = 1, pone todos los pines del banco B (D0~D7) como salida, incluso el pin D0 (Rx) lo que causar que el puerto serial deje de funcionar. {{Nota|En librerías es muy recomendable usar la manipulación directa de registros, así se hacen mucho mas rápidas.}} == Digitales == Bien ahora que ya sabes para que nos meteremos en como manejar estos registros. En principio tenemos dos métodos: masivo es decir todos los puertos de un banco a la vez o puntual es decir un puerto de un banco en particular. === Masivo === Ya sabemos que ATmega 326P maneja 3 bancos (B, C y D) y que cada uno agrupa a un numero de puertos. Por otro lado tenemos 3 registros (DDRx, PORTx y PINx) que podemos manejar. <pre> DDRB = 255; //D8~D13 como salidas. DDRD = B11111111; //D0~D7 como salidas. DDRD = B00000000; //D0~D7 como entradas. DDRB = B00000111; //D8~D10 como salida D11~D13 como entradas. PORTD = B11111111; //D0~D7 en HIGH. PORTD = 0; //D0~D7 en LOW. PORTB = B00000101; //D8+D10 en HIGH, D8, D11~D13 en LOW. byte variable = PIND; //Guarda en una variable los estados de D0~D7 como un byte. </pre> Se debe tener cuidado cuando se usa el PORTD y el puerto serie D0 (Rx) y D1 (Tx) son los usados por la UART y si se pone estos puertos como entradas o salidas, la UART será incapaz de leer o escribir datos en estos puertos. Este es un ejemplo de cuidado que se debe tener al usar esta programación en lugar de la capa de programación que nos ofrece Arduino. Mediante los registros también podemos controlar las resistencias internas de pull-up que se usan básicamente para no dejar los pines al aire ya que esto genera ruido eléctrico. Se puede resolver este problema de dos maneras: poner una resistencia externa de 10K a Vcc (+5V) o usar los Pull-up internos del uC que producen el mismo efecto y hacen mas simple el circuitos. Para habilitar las resistencias pull-up tenemos primero que configurar como entrada (0) el puerto mediante registro DDRx y luego escribir un 1 en el registro PORTx. <pre> DDRD = 0; //Configura todos los puertos del banco PORTD (D0~D7) como entradas. PORTD = B00001111; //Habilitar las Pull-ups de los puertos D0~D3. </pre> Es casi tan fácil como usar las funciones [[digitalRead()]] y [[digitalWrite()]] de Arduino, pero con acceso directo al puerto se puede ahorrar espacio en la memoria flash porque cada operación de leer el estado de un solo puerto ocupa 40 bytes de instrucciones y también puede ganar mucha velocidad, porque las funciones Arduino puede tomar más de 40 ciclos de reloj para leer o escribir un solo bit en un puerto. === Puntual === No es normal que se necesite definir, leer o escribir en un banco completo siempre, por ejemplo, si queremos encender un LED tendremos que actual sobre un solo puerto y no sobre todo el banco. Para eso podemos usar la macro '''Pxn''' donde '''x''' sera el puerto B, C o D y '''n''' sera el bit que estará entre 0~7 para definir el pin en particular. Ver exponencial de tabla arriba. <pre> DDRD = 0<<PD2; //Configura el bit 2 (pin D2) como enteada. DDRB = 1<<PB2; //Configura el bit 2 (pin D10) como salida. DDRB = bit(5); //Configura el bit 5 (pin D13) como salida. PORTD = 1<<PD5; //Pone bit 5 (pin D5) en HIGH. PORTB = 0<<PD2; //Pone bit 2 (pin D10) en LOW. PORTB = PORTB | bit(2); //Pone bit 2 (pin D10) en HIGH. PORTD = PORTD ^ 32; //Conmuta bit 5 (D5). PORTB = 1<<PB5; //Le pone al bit 5 (pin D13) el PULL_UP. byte variable = (PIND & (1<<PD1)); //Lee bit 1 (pin D1) y almacena su valor en la variable. </pre> También podemos usar la macro '''Pxn''' varias veces en una misma instrucción, por ejemplo, en este código, se ejecutará algo de código sólo si los puertos D10 y D11 están en HIGH al mismo tiempo. <pre> DDRB = B00001100; // Los pines D10 y D11 son salidas y el resto (D8+D9+D12+D13) entradas. if (PINB & ((1<<PB2) | (1<<PB3))) { //Algún código que se ejecutará solo si los dos pines de salida (D10+D11) se encuentran en HIGH. } </pre> La manipulación directa de los puertos puede ser acompañada de las máscaras de bits, los operadores lógicos ([[not]], [[and]], [[or]] y [[xor]]) y operaciones de desplazamiento a la derecha e izquierda. El siguiente ejemplo lee alternativamente 100 veces el pin D9 con [[digitalRead()]] y mediante el registro '''PINB''' y calcula el tiempo en microsegundos de ambas operaciones. Te sorprenden los resultados ? <syntaxhighlight lang="c++"> unsigned long t,t1; bool x = true; int y; void setup(){ Serial.begin(115200); pinMode(9, INPUT_PULLUP); } void loop(){ t = micros(); if (x){ for (byte n=0; n<100; n++){ y = digitalRead(9); } }else{ for (byte n=0; n<100; n++){ y = PINB & (1 << PB1); } } t1 = micros() - t; if (x){ Serial.print("DigitalRead() = "); }else{ Serial.print("PINx = "); } x = !x; Serial.println(t1); } </syntaxhighlight> == Analogicos == La forma de manejar con registros las entradas analógicas correspondientes al puerto C con POR y PIN es para usar esos pines como I/O digitales, puesto que los pines de los uC son multipropósito como se ha dicho anteriormente. En las entradas analógicas entran en juego los conversores Analógico Digital (ADC) y en las salidas analógicas entra el [[analogWrite()|PWM]] que usa uno de los temporizadores del uC para hacer la forma de onda [[analogWrite()|PWM]]. === ADC === Un uC solo entiende señales digitales (0+1), por lo que para leer señales analógicas necesitamos un conversos análogo a digital (ADC). El ATmega 329P tiene incluido un conversor analógico a digital (ADC) de 6 canales (por multiplexion) y 10 bits (1024 pasos), por lo que devuelva enteros entre 0~1023. Esto significa que a pesar de que ATmega 328P tiene disponibles 6 pines analogicos (A0~A5) solo puede leer un pin analogico a la vez (por la multilexion), de modo de si requiere lecturas de alta velocidad se podría necesitar el uso de ADC externos. El datasheet de ATmega advierte de hacer lecturas rápidas entre pines analógicos (mas de 200 KHz) puede causar ruido eléctrico, por lo que se recomienda incluir retardos de 1 milisegundo entre lecturas. También es posible alterar la tensión máxima (siempre por debajo de Vcc) que usa el ADC. Es Aref, que es la tensión contra la que todas las entradas analógicas hacen las conversiones. Reducir Aref tiene sentido para mejorar la resolución del ADC. Con Aref = 5V la resolución es de 4,88 mV (5/1023) por paso. Si tienes un sensor de 3V3 mejor pon Vref = 3V3 y obtendrás una resolución de 3.22 mV (3.3/1023) por paso. El ADC interno también se puede usar en un modo de 8 bits (), donde sólo se usan los 8 bits más significativos de la resolución de 10 bits completa, esto podría ser útil cuando se trabaja en ambientes ruidosos y se ahorra tiempo de uC. El ADC también puede configurarse para que lleve a cabo una conversión y detenerse o puede ser configurado para funcionar en un modo de funcionamiento libre, la primera opción es la mejor opción cuando queremos leer diferentes pines, y el segundo es mejor cuando sólo tenemos que leer un pin y esto puede ahorrar algo de tiempo entre las conversiones. === PWM === Las salidas Pulse Width Modulation ([[analogWrite()|PWM]]) permiten simular salidas analógicas con ciertos pines digitales (D3, D5, D6, D9, D10, D11 para Arduino [[UNO]]). [[analogWrite()|PWM]] es una técnica para modificar el ancho de pulsos (duty cycle) de una señal. Lo que modificamos no es la frecuencia que siempre sera 490 Hz (D3, D9, D10 y D11) o 980 Hz (D5 y D6), sino que cambiaremos la proporción de la parte positiva y negativa de cada periodo. Sus usos son: * Generar tensiones analógicas entre 0~100% de Vcc * Generar señales de audio * Controlar velocidad de motores * Varias intensidad de un LED En la familia de uC AVR, el [[analogWrite()|PWM]] se controla por hardware y ATmega 328p cuenta con 3 timers. Timer 0 (D5 + D6) y timer 2 (D3 + D11) dan una resolución de 8 bit (256 pasos) mientras que el timer 1 (D9 + D10) ofrece una resolución de 16 bits (65536 pasos). Todo lo que necesita hacer es inicializar e iniciar el temporizador y establecer el ciclo de trabajo. Estos temporizadores generan interrupciones cuando alcanzan el overflow o cuando alcanzan el registro de comparación. Los registros de control del timer/counter n (donde n 0~2) son TCCRnA y TCCRnB y tienen los principales controles de los temporizadores. == Comentarios == {| class="wikitable col2cen" |+ATmega 328 a 16 MHz |- ! Comando !! ciclos CPU |- | [[digitalRead()]] sin PWM || 58 |- | [[digitalRead()]] con PWM || 72 |- | [[digitalWrite()]] sin PWM || 63 |- | [[digitalWrite()]] con PWM || 77 |- | [[analogRead()]] || 1775 |- | [[analogWrite()]] || 129 |} {| class="wikitable col3cen" |+Operaciones avanzadas |- ! Comando !! Descripcion !! ciclos CPU |- | PINx; || Leer 8 pines || 1 |- | n = PINx; || Leer y almacenar en variable RAM 8 pines || 3 |- | PORTx = B000010000; || Escribir 8 pines || 1 |- | PORTx = n; || Escribir 8 pines desde variable en RAM || 3 |} == Ejemplo == Se requiere definir el pin como salida. {|class="wikitable col3cen" !Pin!!Definición!!Valor |- |D0||PIND = bit(0);||1 |- |D1||PIND = bit(1);||2 |- |D2||PIND = bit(2);||4 |- |D3||PIND = bit(3);||8 |- |D4||PIND = bit(4);||16 |- |D5||PIND = bit(5);||32 |- |D6||PIND = bit(6);||64 |- |D7||PIND = bit(7);||128 |- |D8||PINB = bit(0);||1 |- |D9||PINB = bit(1);||2 |- |D10||PINB = bit(2);||4 |- |D11||PINB = bit(3);||8 |- |D12||PINB = bit(4);||16 |- |D13||PINB = bit(5);||32 |- |A0||PINC = bit(0);||1 |- |A1||PINC = bit(1);||2 |- |A2||PINC = bit(2);||4 |- |A3||PINC = bit(3);||8 |- |A4||PINC = bit(4);||16 |- |A5||PINC = bit(5);||32 |} <syntaxhighlight lang="c++"> void setup(){ DDRB = bit(5); //Define el bit 5 (pin digital 13) como salida. } void loop(){ PORTB = PORTB ^ bit(5); //Invertido estado del bit 5 (pin digital 13), no altera el resto. delay(500); } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ DDRB = B11111111; //Lo mismo que DDRB = 255; } void loop(){ PORTB = 255; //Prende todos los LED D8~D13 delay(500); PORTB = 0; //Apaga todos los LED D8~D13 delay(500); } </syntaxhighlight> == Ejemplo 3 == Parpadea el LED a bordo. <syntaxhighlight lang="c++"> void setup() { DDRB = DDRB | 32; //Configura el pin digital 13 como OUTPUT, no altera el resto. 32=B00100000; } void loop() { PORTB = PORTB ^ 32; //Invertido estado del bit 5 (pin digital 13), no altera el resto. delay(500); } </syntaxhighlight> También se puede usar: PORTB = PORTB <nowiki>^</nowiki> bit(5): == Ejemplo 4 == Se pueden crear definiciones especiales como estas: <syntaxhighlight lang="c++"> #define CLR(puerto,bit) (puerto&=(~(1<<bit))) //CLR(PORTB, 0); #define SET(puerto,bit) (puerto|=(1<<bit)) //SET(PORTB, 0); #define _BV(bit) (1<<(bit)) //PORTB |= _BV(0); o PORTB &= ~(_BV(0)); #define SBI(puerto,bit) (puerto)|=(1<<(bit)) //SBI(PINB, 0); #define RVT(puerto,bit) (puerto=puerto^bit(bit)) //RVT(PORTD, 5); </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones pines</categorytree> == Referencias externas == * [http://arduino.cc/en/Tutorial/PWM Arduino oficial] * [https://www.arduino.cc/en/Reference/PortManipulation PORT manipulation] - Arduino * [http://www.luisllamas.es/2014/09/entradas-analogicas-en-arduino/ Entradas analogicas] - Luis Llamas * [http://panamahitek.com/registro-port-puerto/ El registro PORT] - José Villalaz [[Category:Funciones pines]] mzegsg4znd3i4se6ccft0z4hv231sum 0 484 4850 4849 2019-08-08T00:17:14Z Kike GL 2 wikitext text/x-wiki La mayoría de los puertos de los uC son multipropósito, es decir, en función de su configuración se comportan de una forma u otra. El ATmega 328p como cualquier otro uC tiene registros para cada puerto donde define si sera usado como entrada o salida. Arduio [[MEGA]] tiene 6 bancos o grupos de puertos: A (22~29), B (10~13+50~53), C (30~37), D (18~21+38), E (4+39~41), H (6~9+16+17) es decir a D, E y H le faltan puertos debido a que no se dispone de pines suficientes en el [[MEGA]]. {| class="wikitable" !Banco!!2⁷!!2⁶!!2⁵!!2⁴!!2³!!2²!!2¹!!2⁰ |- |A||29||28||27||26||25||24||23||22 |- |B||13||12||11||10||50||51||52||53 |- |C||30||31||32||33||34||35||36||37 |- |D||-||-||-||38||18||19||20||21 |- |E||-||-||-||-||4||39||40||41 |- |H||-||-||9||8||7||6||16||17 |- !Valor!!128!!64!!32!!16!!8!!4!!2!!1 |} ATmega 2560 tiene 6 registro de 8 bits con los que administra estos 6 bancos: * DDRx, determina si el banco '''x''' sera entrada (0) o salida (1). * PORTx, determina si el banco '''x''' estará en nivel HIGH o LOW. También define Pull-up si es fuera una entrada. * PINx, permite leer estado del banco '''x''' (solo lectura). == Vea también == * [[Programacion avanzada]] - UNO == Referencias externas == [[Category:Funciones pines]] 98wngxl301f00cdejdzn5aall379xg5 0 1 5262 5261 2020-02-05T01:13:31Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki '''ArduWiki''' es una iniciativa que se propuso en el foro de Arduino en español, para intentar tener una documentación aceptablemente buena en nuestro idioma, ya que la original '''Guía de Referencia de Arduino''' es un verdadero desastre y no encontramos la forma de colaborar allí. Es nuestra intención que esto sea temporal y que en algún momento podamos volcar todo este conocimiento a la página oficial. Este wiki es una contribución de algunos [[Entusiastas]]. {{Nota|Si te interesa colaborar con este proyecto y eres por lo menos usuario '''Full Member''' solo tienes que crearte una cuenta en este Wiki (arriba derecha) y luego contactar con '''Kike_GL''' en el foro de Arduino en español, gracias.}} Foro Arduino en Español [https://forum.arduino.cc/index.php?topic=542577.0 aquí] == Que es Arduino ? == Arduino es una plataforma de hardware libre, basada en una placa con un uC (MCU) y un entorno de desarrollo ([[IDE]]), diseñada para facilitar el uso de la electrónica en proyectos multidisciplinarios. Usar Arduino es fácil pero requiere algunos conocimientos básicos de electrónica, componentes electrónicos, cierta habilidad para el ensamblado y programación. {{Nota| Es muy similar a lo que es un [[PLC]] comercial.}} == Placas == Explore toda la gama de productos oficiales de Arduino, incluidos tarjetas, módulos (un factor de forma más pequeño que la placas clásica), escudos o shields (elementos que se pueden enchufar en una placa para darle características adicionales) y kits. {|class="wikitable" !Nombre!!uC!!Operacion!!Entrada!!Velocidad!!Analogicas!!Digitales!!PWM!!EEPROM!!SRAM!!flash!!USB!!UART |- |[[UNO]]||ATmega328P||5 V||7~12 V||16 MHz||6||14||6||1||2||32||Regular||1 |- |[[MINI]]||ATmega328P||5 V||7~9 V||16 MHz||8||14||6||1||2||32||-||- |- |[[MICRO]]||ATmega32U4||5 V||7~12 V||16 MHz||12||20||7||1||2.5||32||Micro||1 |- |[[NANO]]||ATmega168<br>ATmega328P||5 V||7~9 V||16 MHz||8||14||6||0.512<br>1||1<br>2||16<br>32||Mini||1 |- |[[MEGA]]||ATmega2560||5 V||7~12 V||16 MHz||16||54||15||4||8||256||Regular||4 |- |[[PRO]]||ATmega168<br>ATmega328P||3.3 V<br>5 V||3.35~12 V<br>5~12 V||8 MHz<br>16 MHz||6||14||6||0.512<br>1||1<br>2||16<br>32||-||1 |- |[[DUE]]||ATSAM3X8E||3.3 V||7~12 V||84 MHz||12||54||12||-||96||512||2 Micro||4 |- |[[101]]||Intel® Curie||3.3 V||7~12V||32 MHz||6||14||4||-||24||196||Regular||- |- |Gemma||ATtiny85||3.3 V||4~16 V||8 MHz||1||3||2||0.5||0.5||8||Micro||0 |- |LilyPad||ATmega168V<br>ATmega328P||2.7~5.5 V||2.7~5.5 V||8 MHz||6||14||6||0.512||1||16||-||- |- |LilyPad SimpleSnap||ATmega328P||2.7~5.5 V||2.7~5.5 V||8 MHz||4||9||4||1||2||32||-||- |- |LilyPad USB||ATmega32U4||3.3 V||3.8~5 V||8 MHz||4||9||4||1||2.5||32||Micro||- |- |[[MKR1000]]||SAMD21 Cortex-M0+||3.3 V||5 V||48 MHz||7||8||4||-||32||256||Micro||1 |- |Pro Mini||ATmega328P||3.3 V<br>5V||3.35~12 V<br>5-12 V||8 MHz<br>16 MHz||6||14||6||1||2||32||-||1 |- |[[ZERO]]||ATSAMD21G18||3.3 V||7~12 V||48 MHz||6||14||10||-||32||256||2 Micro||2 |- |[[ESPLORA]]||ATmega32U4||5 V||7~12 V||16 MHz||-||-||-||1||2.5||32||Micro||- |- |Ethernet||ATmega328P||5 V||7~12 V||16 MHz||6||14||4||1||2||32||Regular||- |- |[[LEONARDO]]||ATmega32U4||5 V||7~12 V||16 MHz||12||20||7||1||2.5||32||Micro||1 |- |Mega ADK||ATmega2560||5 V||7~12 V||16 MHz||16||54||15||4||8||256||Regular||4 |- |[[Yùn]]||ATmega32U4<br>AR9331 Linux||5 V||-||16 MHz<br>400 MHz||12||20||7||1||2.5<br>16MB||32 MB<br>64 MB||Micro||1 |- |[[MKR ZERO]]||SAMD21<br>Cortex-M0+32bit low power<br>ARM MCU||3.3 V||-||48 MHz||7 (ADC 8/10/12 bit)<br>1 (DAC 10 bit)||22||12||No||32 KB||256 KB||1||1 |} === Nivel básico === Comience con Arduino utilizando productos de nivel de entrada: fácil de usar y listo para impulsar sus primeros proyectos creativos. Estas placas y módulos son los mejores para comenzar a aprender y jugar con la electrónica y la codificación. StarterKit incluye un libro con 15 tutoriales que lo guiarán a través de los conceptos básicos hasta proyectos complejos. * [[UNO]] + [[101]] + [[ESPLORA]] + [[MINI]] + [[MICRO]] + [[NANO]] + [[LEONARDO]] + [[DUO]] === Características mejoradas === Experimente la emoción de proyectos más complejos eligiendo una de las placas con funcionalidades avanzadas o actuaciones más rápidas. * [[MEGA]] + [[ZERO]] + [[MKR ZERO]] === Internet de las Cosas === Haga dispositivos conectados fácilmente con uno de estos productos de IoT y abra su creatividad con las oportunidades de la red mundial. * [[MKR1000]] + [[YUN]] + [[Ethernet]] + [[ESP8266]] == Referencias de lenguaje == # Que es un [[boceto]] o sketch y como funciona ? # Tipos de [[memoria]] en Arduino. # Todo sobre el [[IDE]] de Arduino. * [[Estructura]] los elementos del código de Arduino (C++). * [[Variables]] tipos de datos, contantes y variables en Arduino. * [[Funciones]] para controlar la placa Arduino y realizar cálculos. {{Nota|Si les parece empecemos por aquí.}} <categorytree mode=all>Referencias</categorytree> == Guia de estilo Arduino == # Escribe en primera persona. Al dar instrucciones al lector debes hacerla en segunda persona. # Se claro y conciso, evita el palabreo con frases que no agreguen información. # Cada vez que te refieras a un comando de Arduino, escribelo tan cual se usa respetando mayusculas y minusculas y referencialo. # Explique lo que cada ejemplo hace antes de empezar a codificar. Indicar si se pretende que usuario arme una parte fisica o circuito. # En el código es primordial la '''legibilidad''' no la eficiencia. # Ejemplos deben ser simples, por eso usa [[delay()]] y [[Serial.print()]] sin complejos. # Siempre incluye [[setup()]] y [[loop()]], aunque estén vacíos. # Pon comentario muy cortos. == Ejemplos incluidos en el IDE == Los ejemplos incorporados son [[boceto]]s incluidos en el software Arduino [[IDE]]. Para abrirlos haga clic en el menú de la barra de herramientas: Archivo &gt; Ejemplos. Estos sencillos [[boceto]]s demuestran el uso de todos los comandos básicos de Arduino. En esta sección encontrara los mismos ejemplos traducidos y mejorados. [[Ejemplos incluidos]] <categorytree mode=all>Ejemplos</categorytree> == Tips == Esta es una sección que pretende recopilar Tips de todas partes que sean útiles a los usuarios. <categorytree mode=all>Tips</categorytree> == Librerías == El software Arduino ([[IDE]]) se puede ampliar mediante el uso de librerías, al igual que la mayoría de las plataformas de programación, para proporcionar funcionalidad adicional a sus [[boceto]]s (sketches). A continuación listamos las librerías más importantes explicando su funcionamiento. Además le mostraremos ejemplos de varias librerías que vienen instaladas con el IDE. Para abrirlas haga clic en el menú de la barra de herramientas: Archivo &gt; Ejemplos. Para ver la lista completa de librerías para Arduino, visite la página de Referencia de la librería. [[Librerias]] {{Nota|Esta sección la desarrollara Jopapa}} <categorytree mode=all>Librerias</categorytree> == Módulos == Existen básicamente dos tipos de módulos en Arduino: ;Los mal traducidos escudos (Shields): Son placas de circuitos modulares que se montan unas encima de otras para dar funcionalidad extra a un Arduino ya que respetan su factor de forma. ;El resto: que son los que no cumplen en factor de forma de Arduino y debes instalarlos usando cables. == Electrónica == Arduino requiere conocimientos básicos de electrónica por eso incluimos aquí esta sección. * [https://arduino.perut.org/e_05.htm Entradas] - Apuntes de Arduino * [https://arduino.perut.org/e_05.htm Salidas] - Apuntes de Arduino {{Nota|Por ahora basta con [http://arduino.perut.org/ Mis apuntes sobre Arduino] o [https://itp.nyu.edu ITP Physical Computing]}} == Referencias externas == * [https://www.arduino.cc/ Pagina oficial de Arduino] * [https://www.arduino.cc/reference/es/ Guia de Referencia de Arduino] - el desastre * [https://forum.arduino.cc/index.php?board=32.0 Foro Arduino Español] - contactar [[Usuario:Kike_GL|Kike_GL]] * [https://www.arduino.cc/en/Reference/Libraries Librerías] * [https://www.arduino.cc/en/Reference/StyleGuide Guia de estilo] * [https://campus.programarfacil.com/?menu-curso-arduino Campus Programas Facil] - Luis del Valle * [https://aprendiendoarduino.wordpress.com Aprendiendo Arduino] - Enrique Crespo * [https://manueldelgadocrespo.blogspot.com/ Arduino en español] - Manuel Delgado * [https://www.luisllamas.es/referencia-lenguaje-arduino/ Referencias de Arduino] - Luis Llamas * [https://miarduinounotieneunblog.blogspot.com/ Mi Arduino tiene un Blog] - Mariano del Campo * [https://www.prometec.net/indice-tutoriales/ Tutoriales de Arduino] - Prometec * [https://naylampmechatronics.com/ Tienda Arduino Trujillo] - Naylamp Mecatronics SAC * [http://elcajondeardu.blogspot.com/ El cajon de Arduino] - ECDA 2.0 * [https://www.scoop.it/topic/tecno4 Tecno4] - Gumersindo Fernandez * [https://www.scoop.it/topic/tecno4/p/4026233951/2014/08/13/tutoriales-de-arduino-de-el-profe-garcia Tutorial de Arduino] - El profe Garcia * [https://dronprofesional.com/blog/como-aprender-arduino-desde-cero/ Como aprender Arduino desde cero] - Dron Profesional * [https://www.rinconingenieril.es/ Rincon Ingenieril] - Rincon Ingenieril * [http://www.kio4.com/arduino/index.htm Kio4] - Kio4 * [http://proyectosconarduino.com Proyecto Arduino] * [http://arduino.perut.org Apuntes de Arduino] - Kike_GL [[Category:Arduino]] t1l0sln33qcoj83kvwt101i4n1q5bdm 0 388 4823 4433 2019-07-19T00:25:05Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Recommended Standard 232, también conocido como EIA/TIA RS-232C, es una interfaz que designa una norma para el intercambio de datos binarios serie entre un DTE (Data Terminal Equipment), como por ejemplo una computadora, y un DCE (Data Communication Equipment), por ejemplo un módem. Existen otros casos en los que también se usa la interfaz RS-232. En particular, existen ocasiones en que interesa conectar otro tipo de equipamientos, como pueden ser computadoras. Evidentemente, en el caso de interconexión entre los mismos, se requerirá la conexión de un DTE con otro DTE. Para ello se usa una conexión entre los dos DTE sin usar módem, por ello se llama módem nulo (null modem). El RS-232 consiste en un conector tipo DB-25 (de 25 pines), aunque es normal encontrar la versión DB-9 (de 9 pines) más barato e incluso más extendido para cierto tipo de periféricos (como el ratón serie de la PC). == Historia == La primera especificación de esta interfaz se publicó en 1962 y desde entonces se ha hido revisado frecuentemente. Una de las revisiones más extendidas fue la EIA-232-C. El primer nombre que recibió esta interfaz fue RS-232, nombre que aún hoy se usa ampliamente, a pesar de que dicho estándar lo adoptaría la organización de estadarización norteamericana EIA (Electronic Industries Alliance, o hasta 1997 Electronic Industries Association) cambiando su nombre al actual EIA-232.1​ Posteriormente la ITU-T desarrolló las correspondientes recomendaciones basadas en la interfaz EIA-232. La recomendación V.24 especifica los aspectos funcionales y operacionales, es decir, se define que circuitos o señales tienen que implementarse en la interfaz y la función de cada uno de ellos. Los aspectos eléctricos de la interfaz están definidos en la recomendación V.28.1​ == Pines == {| class="wikitable" |- ! Simbolo !! Señal !! DB-25 !! DB-9 |- | Tx || Transmitted Data || 2 || 3 |- | Rx || Receiver Data || 3 || 2 |- | DTR || Data Terminal Ready || 20 || 4 |- | DSR || Data Set Ready || 6 || 6 |- | RTS || Request To Send || 4 || 7 |- | CTS || Clear To Send || 5 || 8 |- | DCD || Carrier Detect || 8 || 1 |- | RI || Ring Indicator|| 22 || 9 |- | GND || Tierra || 7 || 5 |} == Caracteristicas == * Distancia maxima: 20 m * Velocidad maxima: 20 kbps * Comunicacion: sincrona o asincrona * Tipo canal: simple o duplex * Tension maxima: 25V * Las señales se considerarán en el estado de MARCA, (nivel lógico “1”), cuando la tensión sea más negativa que -3 V con respecto a la línea GND. Las señales se considerarán en el estado de ESPACIO, (nivel lógico “0”), cuando la tensión sea más positiva que +3 V con respecto a GND. La gama de tensiones entre -3 V y +3 V se define como la región de transición, donde la condición de señal no está definida. Si uno de los dispositivos conectados mediante una interfaz RS-232 procesa los datos a una velocidad menor de la que los recibe, deben de conectarse las líneas handshaking (RTS + CTS) que permiten realizar un control de flujo tal que al dispositivo más lento le de tiempo de procesar la información. == Circuitos == La UART (Universal Asynchronous Receiver Transmitter) es el dispositivo que controla los puestos serie {{Nota|Las señales externas pueden ser de variada índole. Ejemplos de estándares para señalización por voltaje son RS-232, RS-422 y RS-485 de la EIA. Históricamente se usó la presencia o ausencia de corriente en circuitos telegráficos.}} == MAX232 == Generalmente, cuando se requiere conectar un uC (con señales típicamente entre 3,3 y 5 V) con un puerto RS-232 estándar, se usa un driver de línea, típicamente un MAX232 o compatible, el cual mediante dobladores de tensión positivos y negativos, permite obtener la señal bipolar (típicamente alrededor de +/- 6V) requerida por el estándar. == Vea también == * [[RS-485]] * [[PLC]] * [[Wire]] == Referencias == [[Category:Ejemplos]] hxg2r5ciudvg78t452bszjkplyad5ex 0 389 4661 2680 2019-07-06T02:35:27Z Kike GL 2 /* Referencias */ wikitext text/x-wiki RS-485 o también conocido como EIA-485, que lleva el nombre del comité que lo convirtió en estándar en 1983. Es un estándar de comunicaciones en bus de la capa física del Modelo OSI. == Historia == Está definido como un sistema de bus diferencial multipunto, es ideal para transmitir a altas velocidades sobre largas distancias (10 Mbit/s hasta 12 metros y 100 kbit/s en 1200 metros) y a través de canales ruidosos, ya que el par trenzado reduce los ruidos que se inducen en la línea de transmisión. El medio físico de transmisión es un par trenzado (aunque existe una topología muy poco común de dos pares trenzados) que admite 32, 128 o 256 estaciones en 1 solo par, con una longitud máxima de 1200 metros operando entre 300 y 19 200 bit/s y la comunicación half-duplex (semiduplex) dependiendo del consumo de cada driver. La transmisión diferencial permite alcanzar mayor distancia con una notable inmunidad al ruido, siempre que el bus de comunicación conserve las características de bus balanceado dando la posibilidad de una configuración multipunto. Desde 2003 está siendo administrado por la Telecommunications Industry Association (TIA) y titulado como TIA-485-A.222. == Caracteristicas == * Interfaz diferencial * Conexión multipunto * Alimentación única de +5V * Hasta 32 estaciones (ya existen interfaces que permiten conectar 256 estaciones) * Velocidad máxima de 10 Mbit/s (a 12 metros) * Longitud máxima de alcance de 1200 metros (a 100 kbit/s) * Rango de bus de -7V a +12V == Aplicaciones == * Se usa con frecuencia en las UARTs para comunicaciones de datos de poca velocidad en las cabinas de los aviones. Por ejemplo, algunas unidades de control del pasajero lo usan, equipos de monitoreo de sistemas fotovoltaicos. Requiere el cableado mínimo, y puede compartir el cableado entre varios asientos. Por lo tanto reduce el peso del sistema. * Se usa en sistemas grandes de iluminación, como los conciertos de música y las producciones de teatro, se usa software especial para controlar remotamente el equipo de iluminación y los diferentes aparatos conectados al bus. * En la automatización de los edificios pues el cableado simple del bus y la longitud de cable es larga por lo que son ideales para ensamblar los dispositivos que se encuentran alejados. * En plantas industriales de producción automatizadas para el manejo de información digital y analógica entre los distintos equipos de la planta. == Vea también == * [[RS-232]] == Referencias == [[Category:Librerias]] 3okm4yj3aeeft11khkfu1y3fuw08fdb 0 399 5150 5144 2020-01-23T22:37:33Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == La librería [https://github.com/adafruit/RTClib RTClib.h] de Adafruit que permite trabajar con un reloj por software (RTC_Millis) y algunos relojes físicos como RTC_DS1307, RTC_DS3231 y PCF8523. == Placas aplicables == Todas. == Sintaxis == <pre> //#include <Wire.h> //Solo si usas reloj fisico #include <RTClib.h> RTC_Millis rtc; //Reloj por software que usa millis() RTC_Micros rtc; //Reloj por software que usa micros() //RTC_DS1307 rtc; //Reloj con DS1307 //RTC_DS3231 rtc; //Reloj con DS3231 //RTC_PCF8523 rtc; //Reloj con PCF8523 </pre> == Parámetros == ;variable:Nombre de la variable a crear. ;año:4 digitos del año. ;mes:2 digitos del mes entre 1~12. ;dia:2 digitos del dia entre 1~31. ;hora:2 digitos de la hora entre 0~23. ;min:2 digitos de los minutos entre 0~59. ;seg:2 digitos de los segundos entre 0~59. == Clases == Esta librería maneja dos clases: * [[DateTime]] - es un tipo de dato * [[TimeSpan()]] - para manejar intervalos de tiempo == Métodos == {| class="wikitable" |+Métodos disponibles libreria RTClib.h |- ! Método !! Descripción |- | .now() || Toma de fecha y hora actual. |- | .adjust() || Ajustar fecha y hora |- | .isrunning() || Devuelve verdadero si esta ajustada la fecha hora. |- | .readSqwPinMode() || Leer el modo. OFF, ON, SquareWave1Hz, SquareWave4kHz, SquareWave8kHz o SquareWave32kHz. |- | .writeSqwPinMode(modo) || Escribir modo. |} {| class="wikitable" |+Modos de sqwPinMode() |- ! Modo !! Frecuencia |- | SquareWave1Hz || 1 kHz |- | SquareWave4Hz || 4.096 kHz |- | SquareWave8Hz || 8.192 kHz |- | SquareWave32Hz || 32.768 kHz |} {| class="wikitable" |+Métodos disponibles clase DateTime |- ! Método !! Descripción |- | .year() || Año |- | .month() || Mes (1~12) |- | .day() || Dia (1~31) |- | .hour() || Horas (0~23) |- | .minute() || Minutos (0~59) |- | .second() || Segundos (0~59) |- | .dayOfTheWeek() || Dia de la semana (0=domingo) |- | .secondstime() || Segundos desde 1-ENE-2000 |- | .unixtime() || Segundos desde 1-ENE-1970 |- | .timestamp() || Formato "2020-01-01T08:00:00 |} {| class="wikitable" |+Métodos clase TimeSpan |- ! Método !! Descripción |- | .days() || Dias (1~31) |- | .hours() || Horas (0~23) |- | .minutes() || Minutos (0~59) |- | .seconds() || Segundos (0~59) |- | .totalsecons() || Segundos totales |} == Comentarios == * Accionar una alarma a las 8 am de cada lunes. <pre> DateTime t = now(); if (t.hour() == 8 && t.dayOfTheWeek() = 2){ //Lo necesario } </pre> * Accionar una alarma cada 45 min (2 700 seg). <pre> DateTime t = now(); if (t.unixtime()%2700 == 0){ //Lo necesario } </pre> == Advertencias == Nada. == Ejemplo 1 == Si usas la librería '''RTClib.h''' tendrás disponible el método '''.unixtime()''' que es excelente para hacer operaciones con fechas. <syntaxhighlight lang="c++"> #include <RTClib.h> DateTime t0 (2018,7,14,8,0,0); //2018-7-14 8:00:00 //Calculos 1 DateTime t1 = t0 + TimeSpan(0,1,0,0); //Añadir una hora DateTime t2 = t0 + TimeSpan(1,0,0,0); //Añadir un dia DateTime t3 = t0 - TimeSpan(7,0,0,0); //Restar una semana //Calculos 2 DateTime unix = t0.unixtime(); //1531555200 DateTime t1 (t0.unixtime() + 3600); //Añadir una hora DateTime t2 (t0.unixtime() + 86400L); //Añadir un dia DateTime t3 (t0.unixtime() - 7*86400L); //Restar una semana //Mostrar Serial.print(t0.unixtime()); //1531555200 Serial.print(t0.year()); //2018 Serial.print(t0.month()); //7 Serial.print(t0.day()); //14 Serial.print(t0.hour()); //8 Serial.print(t0.minute()); //0 Serial.print(t0.second()); //0 </syntaxhighlight> == Ejemplo 2 == Muestra por el monitor serie: año, mes, dia, dia de la semana, hora, minutos y segundos, luego el tiempo Unix y finalmente calcula una fecha futura dentro de: 7 dias, 12 horas, 30 minutos y 6 segundos. <syntaxhighlight lang="c++"> //#include <Wire.h> //Solo si usas reloj fisico #include <RTClib.h> RTC_Millis rtc; //Reloj por software //RTC_DS1307 rtc; //Reloj con DS1307 //RTC_DS3231 rtc; //Reloj con DS3231 char diaSemana[7][12] = {"Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado"}; void setup () { Serial.begin(57600); //Para setear RTC con fecha y hora cuando se compila rtc.begin(DateTime(F(__DATE__), F(__TIME__))); //Para setear RTC a 21-MAR-2019 8:00:00 //rtc.adjust(DateTime(2019, 3, 21, 8, 0, 0)); } void loop () { DateTime hoy = rtc.now(); Serial.print(hoy.year()); Serial.print('-'); Serial.print(hoy.month()); Serial.print('-'); Serial.print(hoy.day()); Serial.print(" ("); Serial.print(diaSemana[hoy.dayOfTheWeek()]); Serial.print(") "); Serial.print(hoy.hour()); Serial.print(':'); Serial.print(hoy.minute()); Serial.print(':'); Serial.println(hoy.second()); Serial.print("Desde 1-ENE-1970 = "); Serial.print("Segundos = "); Serial.println(hoy.unixtime()); Serial.print("Dias = "); Serial.println(hoy.unixtime() / 86400L); //calcula fecha dentro de 7 dias, 12 horas, 30 minutos y 6 segundos DateTime futuro (hoy + TimeSpan(7,12,30,6)); Serial.print("Fecha futura: "); Serial.print(futuro.year()); Serial.print('-'); Serial.print(futuro.month()); Serial.print('-'); Serial.print(futuro.day()); Serial.print(' '); Serial.print(futuro.hour()); Serial.print(':'); Serial.print(futuro.minute()); Serial.print(':'); Serial.print(futuro.second()); Serial.println(); Serial.println(); delay(3000); } </syntaxhighlight> == Ejemplo 3 == Este es un reloj con 12 LED que prende un LED cada 5 segundos <syntaxhighlight lang="c++"> #include <RTClib.h> RTC_Millis rtc; const byte led[12] = {13,2,3,4,5,6,7,8,9,10,11,12}; void setup() { Serial.begin(9600); rtc.adjust(DateTime(__DATE__, __TIME__)); for (byte i=0; i<12; i++){ pinMode(led[i], OUTPUT); } } void loop() { DateTime hoy = rtc.now(); if (hoy.unixtime()%5 == 0){ for (byte i=0; i<12; i++){ digitalWrite(led[i], LOW); } byte hora = hoy.second()/5; digitalWrite(led[hora], HIGH); } } </syntaxhighlight> == Ejemplo 4 == Este es un reloj con LCD y dos pulsadores para corregir la hora. Uno adelante y el otro retrocede. <syntaxhighlight lang="c++"> #include <LiquidCrystal.h> #include <RTClib.h> RTC_Millis rtc; DateTime t; LiquidCrystal lcd(7, 8, 9, 10, 11, 12); void setup() { lcd.begin(16, 2); rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); pinMode(2, INPUT_PULLUP); //Avanza pinMode(3, INPUT_PULLUP); //Retrocede lcd.setCursor(2,0); lcd.print("Hora actual"); } void loop() { t = rtc.now(); disp(); //Ajusta hora if (digitalRead(2) == LOW){ rtc.adjust(t.unixtime()+1); delay(100); } if (digitalRead(3) == LOW){ rtc.adjust(t.unixtime()-1); delay(100); } } void disp(){ lcd.setCursor(4,1); if (t.hour() < 10) lcd.print("0"); lcd.print(t.hour()); lcd.print(":"); if (t.minute()< 10) lcd.print("0"); lcd.print(t.minute()); lcd.print(":"); if (t.second() < 10) lcd.print("0"); lcd.print(t.second()); } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> <categorytree mode=all>Libreria RTC</categorytree> == Referencias == * [https://github.com/adafruit/RTClib RTClib] - Adafruit * [https://www.arduinolibraries.info/libraries All Libraries] * [https://programarfacil.com/blog/arduino-blog/reloj-con-arduino-rtc/ Reloj con Arduino] - Luis Del Valle * [https://www.luisllamas.es/reloj-y-calendario-en-arduino-con-los-rtc-ds1307-y-ds3231/ Reloj y calendario con RTC] - Luis Llamas * [https://naylampmechatronics.com/blog/category/page/2.html Tutorial RTC DS1307] - Naylamp * [https://www.prometec.net/members/avrsanfer/activity/2182/ Proyecto RTC] - Prometec [[Category:Librerias]] [[Category:Libreria RTC]] 7otpc6rolt3iuj09rflxksjqk5o82kj 0 415 3192 2019-05-02T22:46:26Z Kike GL 2 Kike GL trasladó la página [[RTClib.h]] a [[RTC]] wikitext text/x-wiki #REDIRECCIÓN [[RTC]] qxetxajgnnsiomfmee1lbtkbveaup07 0 237 3747 1007 2019-05-06T22:13:09Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 150 3705 3704 2019-05-06T21:53:07Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Este ejemplo muestra cómo leer una entrada analógica en el pin analógico A0, convertir los valores de [[analogRead()]] en voltaje e imprimirlo en el monitor serie del software Arduino (IDE). == Circuito == Conecta un potenciometro de 10K para simular el sensor. Los extremos deben ir a +5V y GND respectivamente el centro (cursor) lo debes conectar al pin analógico A0. Al girar el eje del potenciómetro, cambia la cantidad de resistencia en cada lado del potenciómetro y este se convierte en un divisor de tension. El uC del Arduino tiene un circuito interno denominado [[ADC]] que lee esta tensión y la convierte en un número entre 0~1023. Cuando el eje gira completamente en una dirección, hay 0 voltios que van al pin, y el valor de entrada es 0. Cuando el eje se gira completamente en la dirección opuesta, hay +5V que van al pin A0 y el valor sera 1023. Es decir [[analogRead()]] devuelve un número entre 0~1023 que es proporcional a la cantidad de voltaje que se aplica al pin analogico A0. == Placa aplicable == Todas. == Código == Tenemos un sensor en al pin analógico A0 y queremos saber que tensión esta entregando. <syntaxhighlight lang="c++"> void setup() { Serial.begin(11520); } void loop() { int sensor = analogRead(A0); //Convierte lectura sensor (0~1023) a tension (0~5V) float voltaje = sensor * (5.0 / 1023.0); Serial.println(voltaje); } </syntaxhighlight> == Comentarios == * Nota que '''NO''' es necesario usar [[pinMode()]] en las entradas analogicas. == Vea también == <categorytree mode=all>Basicos</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/ReadAnalogVoltage Ejemplos incluidos] [[Category:Basicos]] sm30rj5pp2e1wl43qsj50walurabgpy 0 382 5052 5049 2019-10-07T22:01:30Z Kike GL 2 /* Vea también */ wikitext text/x-wiki El '''rebote''' es un efecto muy comun en los contactos electricos del tipo pulsadores, interruptores, contactos de rele, etc. Debido a problemas fisicos y mecanicos se produce un chisporroteo, que al ser leido por Arduino se convierte en muchos pulsos de un corto periodo, de forma que el pulsar el boton una sola vez puede causar resultados impredesibles. == Solucion 1 == La mejor solucion es por hardware poniendo un condensador de 1 uF en paralelo con el pulsador. == Solucion 2 == La solución por software mas simple consiste en aplicar un '''pequeño retardo''' luego de cada vez que se detecta la transicion del pulsador. Eso elimina el ruido. <syntaxhighlight lang="c++"> void setup() { pinMode(2, INPUT); //Pulsador pinMode(13, OUTPUT); //LED } void loop() { //Lee la entrada if (digitalRead(2)){ digitalWhite(13, !digitalRead(13)); delay(50); //Retardo que elimina ruido } } </syntaxhighlight> == Solucion 3 == Otra solución simple que funciona la mayoría de las veces es fijarse en el estado anterior del botón asi. <syntaxhighlight lang="c++"> bool estado,anterior; void setup() { pinMode(2, INPUT_PULLUP); //Pulsador pinMode(13, OUTPUT); //LED } void loop() { estado = digitalRead(2); if (!estado && anterior) { digitalWrite(13, !digitalRead(13)); } anterior = estado; } </syntaxhighlight> == Solución 4 == Quizás los puristas que desean desterrar la función [[delay()]] prefieran usar esta solución: <syntaxhighlight lang="c++"> unsigned long tiempo; void setup() { pinMode(2, INPUT); //Pulsador pinMode(13, OUTPUT); //LED } void loop() { //Lee la entrada if (digitalRead(2)){ if (millis() > tiempo + 50){ digitalWhite(13, !digitalRead(13)); tiempo = millis(); } } } </syntaxhighlight> == Solución 5 == Una solución que funciona muchas veces se trata simplemente de comparar el estado del pulsador con su estado anterior y solo actuar si su estado es HIGH y su anterior LOW. <syntaxhighlight lang="c++"> const byte boton = 2; bool estado,anterior; void setup(){ pinMode(LED_BUILTIN, OUTPUT); } void loop() { estado = digitalRead(boton); if (estado && !anterior){ digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); } anterior = estado; } </syntaxhighlight> {{Tip|Este es mi preferido por lo simple.}} == Solución 6 == El siguiente boceto se basa en la versión de rebote de Limor Fried. En este ejemplo, el pulsador retorna HIGH cuando se presiona y LOW cuando no se presiona. Cada vez que el pin de entrada pasa de LOW a HIGH (se pulso el botón), el pin de salida cambia de LOW a HIGH y HIGH a LOW varias veces. Para ignorar este ruino se introduce un retraso mínimo entre las conmutaciones. <syntaxhighlight lang="c++"> const byte boton = 2; //Pulsador const byte led = 13; //LED bool ledState = HIGH; //El estado actual del pin de salida (LED). bool buttonState; //El estado actual del pin de entrada (Pulsador). bool lastButtonState = LOW; //El estado anterior del pin de entrada (Pulsador). unsigned long tiempo = 0; //Ultima vez que cambio la entrada (pulsador) unsigned long retardo = 50; //Tiempo de retardo. Aumentar si salida parpadea void setup() { pinMode(boton, INPUT); pinMode(led, OUTPUT); digitalWrite(led, ledState); } void loop() { //Lee la entrada bool reading = digitalRead(boton); //Comprueba si acaba de pulsar (LOW a HIGH) if (reading != lastButtonState) { //Reinicia temporizador tiempo = millis(); } if ((millis() - tiempo) > retardo) { if (reading != buttonState) { buttonState = reading; //Solo cambia LED si es pulsado if (buttonState) { ledState = !ledState; } } } digitalWrite(led, ledState); lastButtonState = reading; } </syntaxhighlight> == Solución 7 == <syntaxhighlight lang="c++"> bool actual,anterior; unsigned long db; byte modo = 1; void setup(){ Serial.begin(9600); pinMode(2, INPUT_PULLUP); } void loop(){ actual = digitalRead(2); if (!actual && anterior && millis()-db >= 150UL){ modo++; if (modo > 5){ modo = 1; } Serial.println(modo); db = millis(); } anterior = actual; } </syntaxhighlight> == Solución 8 == Eliminación del rebote mediante [http://playground.arduino.cc/code/debounce libreria Debounce] <syntaxhighlight lang="c++"> #include <Debounce.h> Debounce rebote = Debounce(20, 2); //Asigna 20 ms de retardo en pulsador void setup() { pinMode(2, INPUT); //Pulsador pinMode(13, OUTPUT); //LED } void loop() { rebote.update(); //Actualizar instancia de clase digitalWrite(13, rebote.read()); //Obtener pulso } </syntaxhighlight> == Solución 9 == Eliminación del rebote mediante [https://github.com/thomasfredericks/Bounce2/wiki libreria Bounce2] {| class="wikitable" |- ! Método !! Descripción |- | .read() || Lee el estado del pin actualizado. |- | .fell() || Devuelve verdadero si el pin pasa de HIGH a LOW. (falling) |- | .rose() || Devuelve verdadero si el pin pasa de LOW a HIGH. (rising) |} <syntaxhighlight lang="c++"> #include <Bounce2.h> Bounce rebote = Bounce(2, 50); //Instancia de la clase con retardo de 50 ms void setup() { pinMode(2, INPUT_PULLUP); //Pulsador pinMode(13, OUTPUT); //LED } void loop() { rebote.update(); //Actualiza instancia de clase if (rebote.rose()){; //Lee pulsador cuando se suelta digitalWrite(13, !digitalRead(13); //Conmuta LED } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones pines</categorytree> == Referencias == * [http://playground.arduino.cc/code/debounce Playground] * [https://www.luisllamas.es/debounce-interrupciones-arduino/ Debounce] - Luis Llamas * [https://aprendiendoarduino.wordpress.com/2017/06/19/ejemplos-practicos-arduino/ Ejemplos prácticos Arduino] - Enrique Crespo * [https://manueldelgadocrespo.blogspot.com/p/digitalread.html DigitalRead] - Manuel Delgado * [https://programarfacil.com/blog/utilizar-pulsadores-en-arduino/ Utilizar un pulsador sin saber nada de electrónica] - Luis Del Valle * [https://core-electronics.com.au/tutorials/switch-debouncing-with-arduino.html Interruptores, Debouncing y el Arduino] - Core Electronics * [https://manualarduinos52.wordpress.com/2013/12/06/practica-6/ Funcion antirebote] - Manual de practicas Arduino [[Category:Librerias]] 7aek8s7g3fgf4jne3sjg6y9fe1d2q9s 0 251 1026 2018-06-26T21:15:45Z Kike GL 2 Página creada con « == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Bar graph]] [[Category:Pantalla]]» wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == * [[Bar graph]] [[Category:Pantalla]] dpl1g9t6nnfdneowmou5pkakm1mf5kk 0 490 4934 4929 2019-09-21T14:36:05Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == SCADA, acrónimo de Supervisory Control And Data Acquisition (Supervisión, Control y Adquisición de Datos) es un concepto que se emplea para realizar un '''software''' para ordenadores que permite controlar y supervisar procesos industriales a distancia. == Caracteristicas == * Instalación sencilla e inmediata del producto. * Fácil configuración, incluso cuando se trata de una instalación con puestos remotos (WAN) ya que las comunicaciones entre los equipos cliente y el servidor se basan en los estándares de internet (protocolo HTTP). * No precisa programación para la creación de proyectos completamente funcionales, basta “pinchar y arrastrar” los objetos SCADA sobre la superficie de los formularios y establecer las propiedades correspondientes para obtener una solución operativa. * Si se requiere una funcionalidad avanzada que no esté contemplada en los objetos SCADA definidos en Monitoriza no hay problema ya que Monitoriza es extensible mediante programación en C# o VB.Net. También es posible el uso de librerías de terceros desarrolladas para .NET Framework de Windows. * La creación de la interfaz gráfica de usuarios está basada en la tecnología de Windows Forms Designer de Microsoft© lo que facilita de forma notable el diseño. * Fácil creación de gráficas para representar la tendencia de las variables. * Definición inmediata de alarmas. * Fácil seguimiento de variables. * Datos en formatos accesibles. Monitoriza permite almacenar las variables que se monitorizan en bases de datos estándar del mercado (Microsoft© SQL Server™, Microsoft© Access™, Oracle®, etc.) * A nivel de proyecto podemos definir usuarios y los permisos asignados a cada uno ellos. Por ejemplo si solo se tiene permiso de lectura en un determinado formulario o si se tiene acceso total a este. == Vea también == * [[OPC]] * [[PLC]] * [[ArdBox]] * [[PIC]] * [[AVR]] * [[FPGA]] == Referencias externas == * [https://www.wonderware.es/hmi-scada/que-es-scada/ Que es SCADA] * [https://paradiso-fp7.eu/scada/ Beneficios de SCADA] * [http://www.acimut.com/monitoriza/monitorizaforarduino.html SCADA for Arduino] * [http://diymakers.es/software-tools-makers-un-scada-para-arduino/ Un SCADA para Arduino] * [https://www.st4makers.com/ OPC server for Arduino] 1pv24uhbncaqr018o7owlkkxj2umpom 0 390 5276 5275 2020-03-16T17:15:18Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == La librería [https://github.com/arduino-libraries/SD SD.h] de SparkFun habilita un Arduino para la interacción con tarjetas SD (Secure Digital) mediante el protocolo '''Serial Peripheral Interface''' ([[SPI]]). A pesar de que existen tres tamaños distintos, todos operan exactamente de la misma manera (a determinada capacidad); por lo tanto, esta librería funciona con todos los tamaños. Debido a que usa [[SPI]], la conexión debe realizarse hacia los respectivos pines del Arduino; salvo SS/CS, este puede conectarse en cualquier pin digital libre. {{Nota|La librería soporta tarjetas SD del estándar '''SC''' y '''HC'''; por esta razón, la capacidad máxima soportada es de '''32 GB'''.}} {{Tip|Librería oficial, es decir que está preinstalada junto con la [[IDE]] de Arduino, no es necesario descargarla.}} {{Nota|debido a limitaciones de la librería y sistema de archivos compatibles, el tamaño máximo por archivo es de 4 GB o 4294967295 bytes.}} Una mejor opción sera la libreria [https://github.com/greiman/SdFat SdFat] de Bill Greiman que soporta FAT16 y FAT32. == La clase SD == Es un objeto preinstanciado que se utiliza para iniciar la tarjeta y realizar operaciones generales sobre el sistema de archivos ([https://es.wikipedia.org/wiki/Tabla_de_asignaci%C3%B3n_de_archivos FAT] en sus versiones de 16 y 32 bits; '''exFAT''' no es compatible). === Sintaxis === <pre> #include <SPI.h> #include <SD.h> SD.begin(CS); </pre> === Parametros === ;CS:Puerto 4 si es Aduino Shield. === Metodos === {| class="wikitable" |+Metodos de la clase SD |- ! Método !! Descripción |- | [[SD.begin()]] || Intenta inicializar la tarjeta SD al modo SPI, para así obtener de esta la información necesaria para empezar a usarla. |- | [[SD.end()]] || Devuelve la librería al estado inicial; útil para remover, "en caliente" y de forma segura, la tarjeta. |- | [[SD.open()]] || Abre un archivo o una carpeta. |- | [[SD.exists()]] || Verifica si determinado archivo o carpeta realmente existe en la tarjeta. |- | [[SD.remove()]] || Elimina un archivo. |- | [[SD.mkdir()]] || Crea un directorio (carpeta). |- | [[SD.rmdir()]] || Elimina un directorio (carpeta). |} {{Nota|prácticamente ningún otro método funcionará si no se inicializa de antemano la tarjeta SD.}} == La clase File == Es un objeto que representa la instancia de un fichero (archivo) o directorio (carpeta) dentro de la tarjeta SD; con este se interactúa directamente sobre ellos. Se crea mediante las funciones [[SD.open()]] o [[File.openNextFile()]]. === Sintaxis === <pre> File variable1 = SD.open(nombre, modo); File variable2 = variable1.openNextFile(); </pre> === Parámetros === ;variable:Nombre de variable a instanciar. ;nombre:Nombre de archivo SFN (8.3). Ejemplo log12345.txt. ;modo:Puede ser FILE_WRITE o FILE_READ === Metodos === {| class="wikitable" |+Metrodos de la clase File |- !Método!!Descripción |- | [[File.read()]] || Lee un byte/caracter o varios del archivo. |- | [[File.peek()]] || Lee un byte/caracter del archivo sin avanzar al siguiente. |- | [[File.available()]] || Retorna la cantidad de bytes/caracteres disponibles para leer (antes de llegar al final del archivo). |- | [[File.write()]] || Escribe un byte/caracter o varios al archivo. Suele usarse para archivos binarios. |- | [[File.print()]] || Escribe una representación textual de un dato (o una cadena de caracteres) al archivo. Suele usarse para archivos de texto plano. |- | [[File.println()]] || Igual al anterior, excepto que agrega una nueva línea de texto. |- | [[File.flush()]] || Fuerza la actualización de los datos en la tarjeta SD. |- | [[File.seek()]] || Posiciona el "cursor" del archivo hacia una posición dada. |- | [[File.position()]] || Retorna la posición actual del "cursor" del archivo. |- | [[File.size()]] || Retorna el tamaño del archivo (en bytes). |- | [[File.name()]] || Retorna el nombre del archivo/carpeta. |- | [[File.isDirectory()]] || Verifica si esta instancia realmente representa un directorio (carpeta) y no un archivo regular. |- | [[File.openNextFile()]] || Abre el siguiente archivo de la lista (válido si esta instancia representa un directorio/carpeta). |- | [[File.rewindDirectory()]] || Devuelve la iteración de archivos al comienzo (válido si esta instancia representa un directorio/carpeta). |- | [[File.close()]] || Cierra el archivo (o carpeta) para liberar correctamente cualquier recurso que esté siendo utilizado por esta instancia. |} {{Nota|Prácticamente ningún método funcionará si la instancia es "vacía" o representa un archivo/carpeta sin abrir.}} === Formato de la ruta de acceso === Esta librería utiliza el formato de rutas de UNIX/Linux: el nombre de las carpetas involucradas se separa con '''/''' (barra inclinada o slash), siendo el destino final el último nombre de la secuencia. Por ejemplo: <pre> datos.txt ruta/hacia/el/archivo/que/buscamos.txt </pre> Esto hará que el archivo '''datos.txt''' sea creado o buscado en el directorio raíz; en otras palabras, fuera de toda carpeta. {{Nota|Para efectos del sistema de archivos, los nombres '''NO SON''' sensibles a las mayúsculas; por lo tanto, '''datos.txt''', '''Datos.txt''' y '''DATOS.TXT''' hacen referencia al mismo archivo. Lo mismo aplica para directorios/carpetas.}} Siendo '''ruta''', '''hacia''', '''el''', '''archivo''' y '''que''' las carpetas que nos llevan al archivo '''buscamos.txt''' Ese destino no tiene que ser solamente un archivo regular, también podría ser otra carpeta. Si es algo que queremos colocar o ubicar en la "raíz", basta con simplemente colocar el nombre del elemento. Por ejemplo: {{Nota|ya que el directorio de trabajo de la librería siempre es la raíz, da igual que la ruta sea absoluta (con '''/''' al comienzo) o relativa (sin '''/''' al comienzo).}} === Nombres SFN (8.3) === Parte de la escritura de rutas también involucra respetar el formato SFN (Short File Name o nombre corto de archivo), el cuál sigue estas reglas: * El nombre del elemento debe tener como mínimo 1 carácter, y como máximo 8 caracteres. * Si es un archivo regular, debe haber un único punto ('''.''') justo después del nombre. * Si es un archivo regular, deben haber de 1 a 3 caracteres después del antes mencionado punto. Esto es lo que se conoce como la "extensión", una forma burda (pero muy usada en Windows) de etiquetar archivos por su contenido (ej.: '''txt''' para texto plano, '''jpg''' para imágenes codificadas en JPEG, '''mp3''' para audio codificado en MPEG capa 3, etc.). {{Nota|deduciendo de las reglas anteriores, los directorios/carpetas solo deben cumplir la primera; no debe haber punto ('''.''') ni extensión en el nombre.}} === Caracteres permitidos === En el nombre puede venir cualquier carácter, excepto los siguientes: * <code>" * + , / : ; < = > ? \ [ ] | </code> * Los que tienen un valor decimal del 0 al 31 * El carácter de valor decimal 127 * El punto ('''.''') sólo si no es antecedido por al menos un caracter permitido. Técnicamente se permite el carácter espaciador y los del ASCII extendido (valor decimal del 128 al 255), sin embargo el primero no se recomienda porque puede hacer más complicado programar la generación de rutas; y lo segundo tampoco ya que la codificación no es estándar entre regiones geográficas (lo que puede llevar a una interpretación errónea del nombre en cuestión), eso sin contar que si el primer carácter es de valor '''0xE5''' (229 decimal), la librería podría después mal interpretarlo como un archivo eliminado (que no existe). Curiosamente, las letras minúsculas están prohibidas; sin embargo esto no es cierto al crear e ingresar la ruta, ya que la librería automáticamente usa, en su lugar, las respectivas contrapartes mayúsculas al procesarla. === Comentarios === Hereda de la clase [[Stream]], lo que quiere decir que prácticamente comparte la mayoría de métodos (y funcionalidad) de incluso la clase [[Serial]]. Que algunos no sean mencionados en esta página, no quiere decir que no se puedan usar. {{Nota|a partir de la versión 1.0 del [[IDE]] de Arduino, se permite tener múltiples archivos abiertos a la vez.}} {{Nota|El flujo de entrada y salida de esta clase se categorizan como '''por bloques'''.}} {{Nota|Este objeto se puede introducir directamente en un contexto booleano (ej.: como condición de un [[if... else]]); se evaluará como verdadero o '''true''' si el archivo/carpeta que representa está abierto/a en dicha instancia, falso o '''false''' en el caso contrario.}} === Cómo agregar fecha y hora a los archivos === Todo archivo/fichero y directorio/carpeta tiene por atributos, además del nombre, la fecha y hora de creación, último acceso y última modificación (datos que se pueden mirar en las "propiedades" o "detalles" del elemento, en el explorador de archivos de tu PC). La librería por defecto no tiene definido cómo obtener dicha información; pero cuando es requerido, por defecto coloca el '''01/01/2000 1:00:00 am''' aunque haya transcurrido un tiempo desde que el sistema ha arrancado. Para definir la obtención de esos datos, primero debes crear una función con la siguiente "firma" (declaración): <pre>void nombreFuncion(uint16_t* fecha, uint16_t* hora)</pre> '''Quiere decir que dicha función DEBE retornar [[void]] y DEBE tener dos parámetros de tipo [[word|word o uint16_t]][[asterisco|*]]. El nombre no es importante.''' En dicha función, programarás la obtención de la fecha y hora actualizados; que pueden provenir de un reloj generado por software, un reloj NTP o un RTC. Luego, en el [[setup()]], colocas esta línea para así otorgarle dicha definición a la librería: <pre>SdFile::dateTimeCallback(nombreFuncion);</pre> == Advertencias == * Para efectos del sistema de archivos, los nombres '''NO SON''' sensibles a las mayúsculas; por lo tanto, '''datos.txt''', '''Datos.txt''' y '''DATOS.TXT''' hacen referencia al mismo archivo. Lo mismo aplica para directorios/carpetas. * Atento al uso de la [[SRAM]], esta librería suele ser intensiva en ese recurso. Inicialmente consume alrededor de 700 bytes de este tipo de memoria. * La tarjeta debe estar formateada en FAT16 o FAT32 con [https://www.sdcard.org/downloads/formatter_4/ SDFormatter] ('''NUNCA CON LOS UTILITARIOS DEL SISTEMA OPERATIVO'''), de lo contrario no funcionará con la librería o podría tener un bajo rendimiento. == Ejemplo 1 == <syntaxhighlight lang="c++"> void obtenerFechaHora(uint16_t* fecha, uint16_t* hora) { // Aquí llamas al reloj para que actualice los datos *fecha = FAT_DATE(anio, mes, dia); *hora = FAT_TIME(hora, minuto, segundo); } void setup() { // Todas las demás inicializaciones SdFile::dateTimeCallback(obtenerFechaHora); } void loop() { // El resto del programa } </syntaxhighlight> Siendo '''anio''' una variable de tipo [[unsigned int]], mientras que el resto de componentes son de tipo [[byte]]. El año se agrega con un valor que tenga los cuatro dígitos. El rango de fecha y hora válido es del '''01/01/1980 12:00:00 am''' al '''31/12/2107 11:59:59 pm'''. Una vez "adjuntada", esta función se utiliza de manera similar a como ocurre en las [[attachInterrupt()|interrupciones]]: implícitamente cuando la librería la necesite. La fecha/hora de creación se aplica únicamente al momento de crear un archivo/carpeta que antes no existía; la de acceso con el simple hecho de lograr abrirla; y la de modificación cuando se cierra un archivo regular que fue abierto para escritura, o cuando una subcarpeta adquiere o pierde contenido. == Ejemplo 2 == Este ejemplo muestra como conectar SD mediante [[SPI]], con MOSI, MISO, CLK, CS (11,12,13,4). CS puede variar segun si es Arduino Shield (4), Adafuit (19, Sparkfun(8) o MKRZero. Es el mismo ejemplo de '''CardInfo''', solo que los mensajes se han traducido al español. <syntaxhighlight lang="c++"> #include <SPI.h> #include <SD.h> Sd2Card card; SdVolume volume; SdFile root; const int chipSelect = 4; //Arduino Ethernet shield, o cambiar según corresponda. void setup() { Serial.begin(9600); Serial.print("Inicializando SD..."); if (!card.init(SPI_HALF_SPEED, chipSelect)) { Serial.println("Error con SD:"); Serial.println("* la trajeta SD esta puesta ?"); Serial.println("* los cables estan correctos ?"); Serial.println("* pin de chipSelect es correcto segun modelo ?"); while (1); } else { Serial.println("Conexiones correctas y tarjeta SD en su lugar."); } Serial.println(); Serial.print("Tipo de tarjeta: "); switch (card.type()) { case SD_CARD_TYPE_SD1: Serial.println("SD1"); break; case SD_CARD_TYPE_SD2: Serial.println("SD2"); break; case SD_CARD_TYPE_SDHC: Serial.println("SDHC"); break; default: Serial.println("Desconocido"); } if (!volume.init(card)) { Serial.println("No encuentro particion FAT16/FAT32. La tarjeta esta formateada ?"); while (1); } Serial.print("Clusteres: "); Serial.println(volume.clusterCount()); Serial.print("Sectores por Cluster: "); Serial.println(volume.blocksPerCluster()); Serial.print("Total de sectores: "); Serial.println(volume.blocksPerCluster() * volume.clusterCount()); Serial.println(); uint32_t volumesize; Serial.print("El tipo de volumen es: FAT"); Serial.println(volume.fatType(), DEC); volumesize = volume.blocksPerCluster(); volumesize *= volume.clusterCount(); volumesize /= 2; // Bloques (sectores) de una SD son de 512 bytes (2 bloques abarcan 1 KB o 1024 bytes) Serial.print("Tamanio del volumen (KB): "); Serial.println(volumesize); Serial.print("Tamanio del volumen (MB): "); volumesize /= 1024; Serial.println(volumesize); Serial.print("Tamanio del volumen (GB): "); Serial.println((float)volumesize / 1024.0); Serial.println("\r\nArchivos en SD (nombre, fecha y tamanio en bytes): "); root.openRoot(volume); // Mostrar contenido root.ls(LS_R | LS_DATE | LS_SIZE); } void loop(void) { // Nada } </syntaxhighlight> == Ejemplo 3 == Data logger. <syntaxhighlight lang="c++"> #include <SPI.h> #include <SD.h> const int chipSelect = 4; void setup() { Serial.begin(9600); Serial.print("Inicializando SD..."); if (!SD.begin(chipSelect)) { Serial.println("SD fallo, esta puesta ?"); while (1); } Serial.println("SD lista."); } void loop() { String data = ""; for (byte analogPin=0; analogPin<3; analogPin++) { int sensor = analogRead(analogPin); data += String(sensor); if (analogPin < 2) { data += ","; } } File File = SD.open("datalog.txt", FILE_WRITE); if (File) { File.println(data); File.close(); Serial.println(data); }else{ Serial.println("Error abriendo datalog.txt"); } } </syntaxhighlight> == Ejemplo 4 == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries/sd SD] - All Libraries * [http://www.arduino.cc/en/Reference/SD SD] * [https://en.wikipedia.org/wiki/8.3_filename Artículo de Wikipedia sobre los nombres SFN (en inglés)] * [https://www.luisllamas.es/tarjeta-micro-sd-arduino/ Leer y escribir en tarjeta SD] - Luis Llamas * [https://naylampmechatronics.com/blog/38_Tutorial-Arduino-y-memoria-SD-y-micro-SD-.html Memorias SD y microSD] - Naylamp * [https://aprendiendoarduino.wordpress.com/category/sd/ SD] - Enrique Crespo * [http://manueldelgadocrespo.blogspot.com/p/biblioteca-sd.html Biblioteca SD] - Manuel Delgado * [https://www.prometec.net/sdcard/ SDcard] - Prometec * [https://eldesvandejose.com/2016/05/12/la-libreria-sd/ Libreria SD] - El desvan de José [[Category:Librerias]] [[Category:Libreria SD]] 51kbfhkc5kacf3ls1nomm7rc6vqhfl9 0 411 3945 3455 2019-05-17T20:39:05Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Intenta inicializar la tarjeta SD al modo [[SPI]], para así obtener de esta la información necesaria para empezar a usarla. Aunque llamar esta función cuando la tarjeta ya había sido inicializada no la perjudica (y prácticamente no tendría efecto alguno en el programa), de todas formas sería un desperdicio de tiempo ya que ejecutar esta función puede tardar hasta un segundo. Donde sí valdría la pena sería al dar soporte de remoción "en caliente", porque cada vez que una tarjeta SD pierda energía, hay que pasar por este proceso al reinsertarse. == Sintaxis == <pre> SD.begin([velocidad, ]pinCS); </pre> == Parametros == ;velocidad: frecuencia del reloj SPI en Hertz ([[unsigned long]]). Si excede el máximo soportado por el microcontrolador, dicho máximo se utilizará en su lugar. El valor máximo absoluto es de 20000000 (20 MHz). ;pinCS: el número del pin utilizado para la línea "Chip Select" (o "Slave Select"/SS) de la tarjeta ([[byte]]). == Retorna == '''true''' si la tarjeta pudo ser inicializada con éxito, '''false''' en caso contrario ([[bool]]). == Comentarios == Este proceso de inicialización sigue tres pasos: * Poner la tarjeta en modo SPI mediante el envío de cierto comando una cantidad determinada de veces. Si no se da la respuesta esperada en alguno de los intentos, el proceso falla inmediatamente. Esta etapa esencialmente verifica el hardware (lo físico); en otras palabras, puede fallar por mala alimentación (de la tarjeta), mala conexión, o incluso por tarjeta defectuosa o que de pleno no soporta [[SPI]]. * Leer la tabla de particiones (también llamados "volúmenes") para así encontrar alguna con el sistema de archivos FAT (16 o 32). Si se falla en esta etapa, es posible que la tarjeta no esté formateada al sistema FAT. * Abrir el directorio raíz una vez encontrada la partición FAT. Si falla, podría ser problema de hardware (ej.: desconexión de la tarjeta antes de llegar a esta etapa) o el sistema de archivos está dañado (reparable mediante formateo o el comando '''chkdsk''' en Windows). En el momento que alguno fracase, es dónde la función retorna '''false'''. Ya que el dato de retorno no es muy específico para diagnosticar posibles problemas con la tarjeta, se recomienda subir y ejecutar el ejemplo '''CardInfo''' para dicha tarea. Ese programa imprime (en el monitor serial) un mensaje de error dependiendo de en cuál de las dos primeras etapas ha fallado; si llega a imprimir una lista del contenido (archivos y carpetas) de la tarjeta, significa que todo está en orden. == Advertencia == Este método solo estará disponible luego de incluir la libreria [[SD]]. == Ejemplo == <syntaxhighlight lang="c++"> #include <SPI.h> #include <SD.h> void setup() { Serial.begin(9600); if (!SD.begin(4)){ Serial.println("Fallo en la tarjeta"); }else{ Serial.println("Tarjeta iniciada"); } //Hacer algo con la SD SD.end() Serial.println("Puedes sacar la tarjeta con seguridad."); } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias externas == * [https://github.com/arduino-libraries/SD Libreria SD] * [https://www.arduinolibraries.info/libraries All Libraries] [[Category:Libreria SD]] 6p1634gqv9gyy6mpg2j6g7i2f4881cj 0 412 4605 3946 2019-07-03T19:22:54Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Devuelve la librería al estado inicial, usualmente para mantener la consistencia ante eventos como la remoción de la tarjeta mientras el programa está corriendo. == Sintaxis == <pre> SD.end(); </pre> == Parametros == Nada. == Retorna == Nada. == Advertencias == * Este método solo estará disponible luego de incluir la libreria [[SD]] y haber usado el motodo [[SD.begin()]]. * Antes de llamar esta función, asegúrate primero de [[File.close()|cerrar]] cualquier archivo previamente abierto. == Ejemplo == <syntaxhighlight lang="c++"> #include <SPI.h> #include <SD.h> void setup() { Serial.begin(9600); if (SD.begin(4)){ Serial.println("Tarjeta SD lista"); }else{ Serial.println("Fallo en la tarjeta SD"); } // Hacer algo más con la tarjeta SD.end(); Serial.println("Ahora se puede retirar la tarjeta con seguridad"); } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias externas == * [https://github.com/arduino-libraries/SD Libreria SD] * [https://www.arduinolibraries.info/libraries All Libraries] [[Category:Libreria SD]] cn57zjewpyagnsaw6nw0j5rimzj1ha4 0 424 4606 3949 2019-07-03T19:27:04Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Verifica si la ruta hacia cierto elemento (archivo o carpeta) realmente existe. == Sintaxis == <pre> SD.exists(ruta); </pre> == Parametros == ;ruta: ruta hacia el archivo o carpeta que se pretende verificar, o sólo el nombre para ubicarlo en la "raíz" ([[string]] o [[String]]). == Retorna == '''true''' si el elemento existe en dicha ubicación, '''false''' en caso contrario ([[bool]]). == Advertencias == Nada. == Ejemplo == Similar al ejemplo 2 de [[SD.open()]], solo que utilizando esta función. <syntaxhighlight lang="c++"> #include <SPI.h> #include <SD.h> File archivo; void setup() { if (!SD.begin(chipSelect)) { Serial.println("SD fallo, esta puesta ?"); while (1); } Serial.println("SD lista."); char nombre[13]; unsigned int contador = 0; sprintf(nombre, "DATA%04d.CSV", contador); while (SD.exists(nombre)) { if (++contador > 9999) { //Si ya se agotaron los cuatro dígitos, no queda de otra que sobrescribir desde la 0000. contador = 0; //Lo malo es que esto siempre lo haría si llegara a suceder. sprintf(nombre, "DATA%04d.CSV", contador); break; } sprintf(nombre, "DATA%04d.CSV", contador); } archivo = SD.open(nombre, FILE_WRITE | O_TRUNC); } void loop() { //A este punto ya es cuestión de solamente usar la instancia. } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] sg839pglpx9ft3ce968l97i06qj9ct3 0 427 3950 3458 2019-05-17T20:40:24Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Crea un directorio (carpeta) o toda una ruta (jerarquía). Para esto último, automáticamente se crea cualquier directorio faltante que la conforma. == Sintaxis == <pre> SD.mkdir(ruta); </pre> == Parametros == ;ruta: carpeta o ruta que se pretende crear ([[string]] o [[String]]). Esta siempre será relativa a la raíz; en otras palabras, siempre será absoluta para efectos del sistema de archivos. == Retorna == '''true''' si se pudo crear, '''false''' en caso contrario ([[bool]]). Si falla, es por error de hardware o porque el "volumen" está lleno. == Advertencias == Nada. == Ejemplo == Creamos una separación (en carpetas) de imágenes según el año de obtención, desde el 1990 hasta el año que se creó esta página (2019). Cada año estará separado por sus meses. <syntaxhighlight lang="c++"> #include <SPI.h> #include <SD.h> void setup() { Serial.begin(9600); Serial.print("Inicializando SD..."); if (!SD.begin(chipSelect)) { Serial.println("SD fallo, esta puesta ?"); while (1); } Serial.println("SD lista."); char ruta[50]; // Algunos nombres fueron recortados para respetar el límite de 8 caracteres. Si fuera el caso, se podrían abreviar por las tres primeras letras. char mes[12][] = {"Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Setiembr", "Octubre", "Noviembr", "Diciembr"}; for (unsigned int anio=1990; anio<=2019; anio++) { for (byte m=0; i<12; i++) { sprintf(ruta, "Imagenes/%d/%s", anio, mes[m]); if (SD.mkdir(ruta)) { Serial.print("La ruta "); Serial.print(ruta); Serial.print(" se ha creado con éxito!"); }else { Serial.print("La ruta "); Serial.print(ruta); Serial.print(" no se ha podido crear!"); } } } } void loop() { //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == * [https://www.arduinolibraries.info/libraries All Libraries] * [http://www.arduino.cc/en/Reference/SD SD] [[Category:Libreria SD]] lm0qzxh4b2w7neh2moectbavkaji5zd 0 475 4629 4616 2019-07-03T21:27:21Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == Es el método principal para crear la instancia de la '''clase File''' (fichero/archivo) o directorio (carpeta) dentro de la tarjeta SD; con este se interactúa directamente sobre ellos. {{Tip|También se puede usar el método [[File.openNextFile()]].}} == Sintaxis == <pre> File variable = SD.open(nombre, modo); </pre> == Parámetros == ;variable:Nombre de variable a instanciar. ;nombre:Nombre de archivo SFN (8.3). Ejemplo log12345.txt. ;modo:Puede ser FILE_WRITE o FILE_READ == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias externas == [[Category:Libreria SD]] 5jhgzv3h29pxo012r4gudnxpmdlgg0z 0 425 3948 3457 2019-05-17T20:39:55Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Elimina el archivo en la ruta dada. == Sintaxis == <pre> SD.remove(ruta); </pre> == Parametros == ;ruta: ruta hacia el archivo que se pretende eliminar, o sólo el nombre para ubicarlo en la "raíz" ([[string]] o [[String]]). == Retorna == '''true''' si se pudo eliminar, '''false''' en caso contrario ([[bool]]). Si falla, es porque el archivo no existe en esa ubicación, o la ruta apunta a un directorio/carpeta. == Advertencias == * Asegúrate de que dicho archivo no esté abierto antes de intentar eliminarlo. * Esta función no puede eliminar carpetas; para eso, usa [[SD.rmdir()]] en su lugar. == Ejemplo == <syntaxhighlight lang="c++"> #include <SPI.h> #include <SD.h> const char[] nombre = "Borrame.txt"; void setup() { Serial.begin(9600); // Inicializamos la tarjeta por supuesto if (SD.remove(nombre)) { Serial.print(nombre); Serial.println(" se ha logrado eliminar."); } else { Serial.print(nombre); Serial.println(" no se puede eliminar porque no existe."); } } void loop() { //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] c092lop87wk5yj1763zw8fey43l0d0q 0 426 3947 3460 2019-05-17T20:39:41Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Elimina el directorio (carpeta) en la ruta dada. == Sintaxis == <pre> SD.rmdir(ruta); </pre> == Parametros == ;ruta: ruta hacia la carpeta que se pretende eliminar, o sólo el nombre para ubicarlo en la "raíz" ([[string]] o [[String]]). == Retorna == '''true''' si se pudo eliminar, '''false''' en caso contrario ([[bool]]). Si falla, es porque el directorio no existe en esa ubicación, existe pero no está vacío, o la ruta apunta a un archivo regular. == Advertencias == * Asegúrate de que dicha carpeta no esté abierta antes de intentar eliminarla. * Por razones obvias, la "raíz" nunca se puede eliminar. == Ejemplo == <syntaxhighlight lang="c++"> #include <SPI.h> #include <SD.h> const char[] nombre = "Imagenes"; // Debe ser una carpeta, por eso no lleva extensión void setup() { Serial.begin(9600); // Inicializamos la tarjeta por supuesto if (SD.rmdir(nombre)) { Serial.print("La carpeta "); Serial.print(nombre); Serial.println(" se ha logrado eliminar."); } else { Serial.print("La carpeta "); Serial.print(nombre); Serial.println(" no se puede eliminar porque no existe o no esta vacia."); } } void loop() { //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria SD</categorytree> == Referencias == [[Category:Libreria SD]] pfgs5vkgal2ulbsnusj8c880ofvmdjn 0 122 3378 3270 2019-05-05T04:35:07Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Esta librería permite comunicarse con dispositivos SPI, usando Arduino como elemento maestro (master) Serial Peripheral Interface (SPI) es un protocolo de de comunicación serie rápida entre dispositivos a corta distancia. Aparte de entre Arduino y periféricos, también permite comunicación entre microcontroladores. En una comunicación SPI hay siempre un maestro (master) que controla los periféricos. Típicamente hay tres líneas de control comunes a todos los elementos. * MISO (Master In Slave Out)- Línea para mandar datos al maestro desde el esclavo * MOSI (Master Out Slave IN)- Línea para mandar datos a los periféricos * SCK (Serial Clock)- Pulsos de reloj para sincronizar la transmisión de datos generada por el maestro a una línea específica de cada periférico. * SS (Slave Select)- El pin en cada periférico que el maestro activa o desactiva para que los datos lleguen al dispositivo que queremos. Cuando el SS (Slave Select) esta bajo (low), el comunica con el maestro y lo ignora cuando esta en alto (high). Esto nos permite tener múltiples dispositivos compartiendo las mismas líneas de MISO, MOSI y CLK. == Placas aplicables == La siguiente tabla muestra en que pines están las líneas SPI en diferentes placas. {| class="wikitable col5cen col6cen col7cen" |+Pines SPI en varios Arduino |- ! Arduino/Genuino ! MOSI ! MISO ! SCK ! SS (slave) ! SS (master) ! Nivel |- | Uno o Duemilove | 11 ó ICSP-4 | 12 ó ICSP-1 | 13 ó ICSP-3 | 10 | -- | 5V |- | Mega1280 ó 2560 | 51 ó ICSP-4 | 50 ó ICSP-1 | 52 ó ICSP-3 | 53 | -- | 5V |- | Leonardo | ICSP-4 | ICSP-1 | ICSP-3 | -- | -- | 5V |- | Due | ICSP-4 | ICSP-1 | ICSP-3 | -- | 4, 10, 52 | 3,3V |- | Zero | ICSP-4 | ICSP-1 | ICSP-3 | -- | -- | 3,3V |- | 101 | 11 ó ICSP-4 | 12 ó ICSP-1 | 13 ó ICSP-3 | 10 | 10 | 3,3V |- | MKR1000 | 8 | 10 | 9 | -- | -- | 3,3V |} {{Nota|Es importante que las líneas MISO, MOSI y SCK están disponibles en una localización fija en un conector ICSP, esto es útil en el diseño de escudos (shield) que funcionen en todas la placas.}} == Sintaxis == <pre> #include <SPI.h> SPI.begin(); </pre> == Modos de operacion == En términos generales, hay cuatro modos de transmisión. Estos modos controlan si los datos se desplazan hacia adentro y hacia afuera en el borde ascendente o descendente de la señal del reloj de datos (fase del reloj), y si el reloj está inactivo cuando está alto o bajo (polaridad del reloj). Los cuatro modos combinan polaridad y fase según esta tabla: {| class="wikitable col2cen col3cen col4cen col5cen" |+Modos de operacion de SPI |- ! Mode ! Clock Polarity ! Clock Phase ! Output Edge ! Data Capture |- | SPI_MODE0 | 0 | 0 | Falling | Rising |- | SPI_MODE1 | 0 | 1 | Rising | Falling |- | SPI_MODE2 | 1 | 0 | Rising | Falling |- | SPI_MODE3 | 1 | 1 | Falling | Rising |} <pre> setDataMode (SPI_MODE0); </pre> Una vez que tenga sus parámetros SPI, use SPI.beginTransaction() para comenzar a usar el puerto SPI. El puerto SPI se configurará con todos sus parámetros. La forma más simple y eficiente de usar SPISettings es hacerlo dentro de SPI.beginTransaction(). Por ejemplo: <pre> SPI.beginTransaction(SPISettings (14000000, MSBFIRST, SPI_MODE0)); </pre> Si otras bibliotecas usan SPI desde interrupciones, se les impedirá acceder a SPI hasta que llame a SPI.endTransaction(). La configuración de SPI se aplica al comienzo de la transacción y SPI.endTransaction() no cambia la configuración de SPI. A menos que usted, o alguna biblioteca, llame a startTransaction() por segunda vez, la configuración se mantiene. Debe intentar minimizar el tiempo entre antes de llamar a SPI.endTransaction(), para obtener la mejor compatibilidad si su programa se usa junto con otras bibliotecas que usan SPI. Con la mayoría de los dispositivos SPI, después de SPI.beginTransaction (), escribirá el pin de selección esclavo LOW, llamará SPI.transfer() cualquier cantidad de veces para transferir datos, luego poner el pin '''SS''' HIGH, y finalmente llamar a SPI.endTransaction() == Métodos == {| class="wikitable col2cen col3cen col4cen col5cen" |+Metodos disponibles en libreria SPI |- ! Método !! Descripción |- | SPI.begin() || Inicializa el bus SPI |- | SPI.transfer(c) || Envia un byte. |- | SPI.attachInterrup() || Activa una interrupcion para recibir datos |- | SPI.beginTransaction() || Inicializa el bus SPI usando lo definido en SPISettings |- | SPI.endTransaction() || Detiene el bus SPI. Normalmente es llamado después de deseleccionar el chip para permitir a otras librerías usar el bus. |- | usingInterrupt() || Si su programa realizará transacciones SPI dentro de una interrupción, llame a esta función para registrar el número o nombre de la interrupción con la biblioteca SPI. Esto permite que SPI.beginTransaction() evite conflictos de uso. Tenga en cuenta que la interrupción especificada en la llamada a usingInterrupt() se deshabilitará en una llamada a beginTransaction() y se volverá a habilitar en endTransaction(). |} == Comentarios == Para escribir código para un dispositivo SPI hay que saber unas pocas cosas. * Cual es la máxima velocidad del dispositivo? Esto es controlado por el primer parámetro in el SPISetting. Si se usa un chip a 15MHz, use 15000000. Arduino automaticamente usará la mejor velocidad igual o menor que esta. * Estan los datos desplazados (shifted) en el mayor Most Significant Bit (MSB) o menor Least Significant Bit (LSB)? Esto es controlado por el segundo parámetro del SPISetting, o sea MSBFIRTS o LSBFIRTS. La mayoría de chip SPI usan el MSB. * Esta el reloj de datos con alto o bajo? ¿Hay muestras en el borde ascendente o descendente de los pulsos de reloj? Este modo es controlado por el tercer parámetro del SPISetting. == Advertencias == Tener en cuenta que el estandar para SPI no existe y su implementación varia levemente entre dispositivos. Hay que leer la hoja de datos de cada uno. == Ejemplos == * [https://www.arduino.cc/en/Tutorial/BarometricPressureSensor Sensor barométrico de presión] * [https://www.arduino.cc/en/Tutorial/DigitalPotControl Control de potenciómetro digital] == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] * [https://github.com/adafruit Adafruid librarys] * [https://www.arduino.cc/en/Reference/Wire Wire] * [https://www.arduino.cc/en/reference/SPI SPI] * [http://arduino.perut.org/Arduino_19.htm Apuntes Arduino] * [https://www.luisllamas.es/arduino-spi/ Bus SPI] - Luis Llamas * [https://aprendiendoarduino.wordpress.com/category/bus-spi/ Bus SPI] - Enrique Crespo * [http://www.gammon.com.au/spi Bus SPI] - Nick Gammon [[Category:Librerias]] myp4bh5yubne2q7n2nhfo6wju8nggg3 0 334 3765 3764 2019-05-06T22:21:58Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == La '''Static Random Access Memory''' es volatil y es donde se almacena los registros, las variables locales y datos parciales. Es la zona de memoria donde el boceto crea y manipula las variables cuando se ejecuta. Es la mas rápida y la unica que puede se escrita desde el boceto en ejecución. Es un recurso escaso que debe gestionarse, especialmente si usamos cadenas de caracteres de forma intensiva. Si un Arduino se queda sin memoria RAM, el boceto compila bien y se cargará en el Arduino sin problema, pero se producirán efectos de respuesta inesperados. En caso que necesites muchas cadenas, una técnica para evitar agotar la memoria '''SRAM''' es guardar en la memoria flash las cadenas que no se modifiquen en tiempo de ejecución, usando PROGMEM osea F(). Es usada para los siguientes propósitos: ;Static Data: Este bloque de memoria es reservado en la RAM para todas las variables globales y estáticas. Para cada variable que es definida se separa el espacio adecuado según el tipo sin importar si se usa o no. Luego Arduino copiara los valores iniciales desde el boceto compilado en la flash. ;Heap: Este bloque es usado para las variables o elementos que asignan memoria dinámicamente. Crece desde el final de la zona de Static Data a medida que la memoria es asignada. Usada por elementos como los objetos y vectores/matrices creados por objetos ([[String]] es un ejemplo de ello) o variables locales. ;Stack: Este bloque es usado por las variables locales y para mantener un registro de las interrupciones y las llamadas a funciones. La pila crece desde la zona más alta de memoria hacia el bloque Heap. Cada interrupción, llamada de una función o llamada de una variable local produce el crecimiento de esta memoria. La mayor parte de los problemas ocurren cuando los bloques Heap y Stack colisionan. Cuando esto ocurre uno o ambas bloques de memoria se corrompen con resultados impredecibles. En uno casos se produce un “cuelgue” del Arduino o resultados impredescibles. {{Nota|Luego de compilar el bocetos, desde la versión 1.6 del [[IDE]], Arduino informa sobre el tamaño de la '''SRAM''' que sera ocupado por variables globales, es decir el bloque static data.}} {|class="wikitable col2cen col3cen col4cen" |+Memoria en cada Arduino !Tipo!!Arduino [[UNO]]!!Arduino [[MEGA]]!!Arduino [[MKR1000]] |- |[[flash]]||32K||256K||256K |- |Flash-bootloader||0.5K||8K||- |- |SRAM||2K||8K||32K |- |[[EEPROM]]||1K||4K||- |} == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>memoria</categorytree> == Referencias == * [https://www.luisllamas.es/guardar-variables-entre-reinicios-con-arduino-y-la-memoria-no-volatil-eeprom/ Variables y memoria no volatil] - Luis Llamas * [https://programarfacil.com/blog/tipos-de-memoria/ Tipos de memoria] - Luis Del Valle [[Category:memoria]] eiouie9hhm3276ogcyvcrgh7bseaduz 0 222 4638 4158 2019-07-04T16:33:38Z Kike GL 2 /* Referencias */ wikitext text/x-wiki Implementación en forma de objeto utilizada para simplificar el uso del puerto serial (USART) por hardware. Se usa para la comunicación entre la placa Arduino y una computadora u otros dispositivos. Todas las placas Arduino tienen al menos un puerto serie. En el caso del ATmega328P ([[UNO]], [[NANO]], [[MINI]]), solo tiene uno y se conecta a los pines 0 y 1; mientras que el ATmega2560 ([[MEGA]]) tiene cuatro, y sus pines están demarcados en la placa. Por lo tanto, si requiere usar USB no puede usar los pines 0 y 1 para entrada o salida digital.<br> Cuando el microcontrolador posee más de un puerto serial por hardware, las respectivas instancias se pueden diferenciar mediante el número al final del nombre. Por ejemplo, el Arduino [[MEGA]] tiene: '''Serial''' (este es el que también va al USB), '''Serial1''', '''Serial2''' y '''Serial3'''; cada una para manipular un puerto distinto. Esta clase hereda de [[Stream]]; por lo tanto todas sus funciones se pueden utilizar aquí también. {{Nota|Puede usar el monitor serie integrado del [[IDE]] Arduino para comunicarse con una placa Arduino. Haga clic en el botón del monitor serie en la barra de herramientas y seleccione la misma velocidad en baudios que introdujo en [[Serial.begin()]].}} {{Nota|El flujo de entrada y salida de esta clase se categorizan como '''byte a byte asincrónico'''.}} == Metodos == {|class="wikitable" |+Metodos disponibles para Serial |- !Método!!Descripción |- |[[Serial.begin()]]||Abre el puerto serie, fija su configuración y velocidad de comunicación. |- |[[Serial.setTimeout()]]||Cambia el tiempo de espera (de la llegada de nuevos datos). |- |[[Serial.getTimeout()]]||Retorna el tiempo de espera actualmente configurado. |- |[[Serial.available()]]||Indica el numero de bytes/caracteres disponibles para lectura. |- |[[Serial.read()]]||Lee un carácter disponible y lo borra del buffer. |- |[[Serial.readBytes()]]||Lee uno o más bytes desde el puerto serie, y los almacena en el buffer/vector/matriz espeficificado. |- |[[Serial.readBytesUntil()]]||Similar al anterior, excepto que con la posibilidad de además finalizar con un terminador. |- |[[Serial.readString()]]||Convierte el flujo de entrada en un objeto [[String]]. |- |[[Serial.readStringUntil()]]||Similar al anterior, excepto que con la posibilidad de además finalizar con un terminador. |- |[[Serial.peek()]]||Lee un carácter disponible pero queda disponible en el buffer (no borra). |- |[[Serial.write()]]||Envia datos binarios al puerto serie. |- |[[Serial.availableForWrite()]]||Indica el numero de caracteres que todavía están pendientes de transmitirse. |- |[[Serial.print()]]||Imprime una representación textual de un dato. |- |[[Serial.println()]]||Imprime una representación textual de un dato junto con un salto de línea; o solo este último. |- |[[Serial.flush()]]||Bloquea la ejecución hasta que el buffer de salida se haya vaciado. |- |[[Serial.find()]]||Lee datos hasta encontrar una coincidencia con una cadena de caracteres o bytes. |- |[[Serial.findUntil()]]||Similar al anterior, excepto que con la posibilidad de además finalizar con una cadena terminadora. |- |[[Serial.parseInt()]]||Convierte el flujo de entrada en un valor entero [[int]]. |- |[[Serial.parseFloat()]]||Convierte el flujo de entrada en un valor punto flotante [[float]]. |- |[[Serial.end()]]||Desactiva la comunicación y libera los pines Rx y Tx asociados. |} == Comentarios == * En el [[IDE]] hay una pantalla que se llama el '''Monitor serie''' donde se puede hacer que Arduino escriba cosas (vía [[Serial.print()]] o [[Serial.write()]]), pero también se puede enviar datos hacia Arduino (desde la primera linea) que luego se puede capturar en Arduino con [[Serial.read()]]. * No es muy conocido, pero todas las funciones de escritura y las de lectura a múltiples bytes, en realidad retornan un valor entero: la cantidad real de bytes que fueron escritos o leídos con éxito. * [[Serial.parseInt()]] y [[Serial.parseFloat()]] opcionalmente pueden recibir un [[char]], este se usará para excluirlo de los caracteres inválidos (que obligan a terminar la conversión), pero sin afectar la conversión. Útil para números separados en milésimas (ej.: "1 000 000"). En [[Serial.parseFloat()]] no se debe ingresar el punto ('''.'''); de lo contrario fallará en reconocer las cifras decimales. {| class="wikitable" |+ATmega 328 a 16 MHz |- ! Comando !! ciclos CPU |- | Serial.print("Hola mundo") con buffer libre || 9600 baud = 1816 / 115200 baud = 1904 |- | Serial.print("Hola mundo") con buffer lleno || 9600 baud = 183021 / 115200 baud = 14941 |- | Serial.write() con buffer libre || 9600 baud = 154 / 115200 baud = 162 |- | Serial.write() con buffer lleno || 9600 baud = 16621 / 115200 baud = 1338 |} == Advertencias == * Desde [[IDE]] v1.0 la transmision en serie es asincrona. * Arduino [[UNO]] y [[MINI]] solo tiene un puerto Serie implementado por hardware en los pines digitales 0 (Rx) y 1 (Tx). No se recomienda usar los pines digitales 0 (Rx) y 1 (Tx) para entrada o salida si requerirás usar el monitor serie. * Arduino [[MEGA]] y [[DUO]] tiene 4 puertos serie implementados por hardware. * La comunicación serial en los pines Tx / Rx usa niveles lógicos TTL (5V o 3V3 dependiendo de la placa). No conecte estos pines directamente a un puerto serial RS232; funcionan a +/- 12V y pueden dañar su placa Arduino. Puedes usar el IC MAX3222. * Si necesitas mas puertos los puedes implementar por software con la librería '''SoftwareSerial.h'''. Posee las mismas funciones antes descritas (también hereda de [[Stream]]). * Hay un "bug" o fallo con [[Serial.readString()]] y [[Serial.readStringUntil()]]: si el flujo de entrada es constante (tiempo de espera nunca se agota) y se llama a alguna de estas funciones, se corre el riesgo de colgar completamente el programa. La razón se debe a que, conceptualmente, [[String]] es ilimitado en tamaño; pero como la [[SRAM]] no es así, eventualmente el programa llegará a colapsar. * Si requiere usar USB no puede usar los pines 0 y 1 para entrada o salida digital. == Vea también == * [[SoftwareSerial]] * [[sprintf()]] <categorytree mode=all>Serial</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/functions/communication/serial/ Guía de referencia] * [https://www.luisllamas.es/puerto-serie-avanzado-arduino/ Comunicación avanzada por puerto serie] - Luis Llamas * [https://www.luisllamas.es/estructuras-puerto-serie-arduino/ Enviar un objeto o estructura por puerto serie] - Luis Llamas * [https://www.luisllamas.es/arduino-caracteres-control-puerto-serie/ Caracteres de control en puerto serie] - Luis Llamas * [https://www.luisllamas.es/array-puerto-serie-arduino/ Enviar o recibir una matriz por puerto serie] - Luis Llamas * [https://www.luisllamas.es/arduino-bytes-puerto-serie/ Enviar o recibir bytes por puerto serie] - Luis Llamas * [https://aprendiendoarduino.wordpress.com/tag/rs232/ Comunicación serie Arduino] - Enrique Crespo * [https://naylampmechatronics.com/blog/24_configuracion-del-modulo-bluetooth-hc-05-usa.html Bluetooth HC-05] - Naylamp * [https://itp.nyu.edu/physcomp/lessons/serial-communication/serial-communication-the-basics/ Serial communication] - ITP Informatica Fisica * [http://diymakers.es/usando-el-puerto-serie-del-arduino/ Usando el puerto serie del Arduino] - Diy Makers [[Category:Serial]] c9x25t873070izx5jm9lxvjnnxfb43z 0 295 3541 3534 2019-05-06T17:43:52Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripcion == Obtiene un número entero con el número de bytes (caracteres) disponibles para leer o capturar desde el puerto serie. Se usa para vigilar si el usuario ingreso datos. == Sintexis == <pre> Serial.available(); </pre> == Parametros == Nada. == Retorna == La cantidad de bytes/caracteres disponibles para lectura ([[int]]). == Advertencias == El buffer de lectura es de 64K. == Ejemplo 1 == Es este ejemplo al capturar el carácter en [[char]] lo podemos imprimir directamente. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ //Espera algo en el buffer char lee = Serial.read(); //Lee el buffer y lo borra Serial.print(lee); //Imprime el caracter } } </syntaxhighlight> == Ejemplo 2 == Es este ejemplo al capturar el carácter en [[byte]] se imprime el código ASCCI <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte lee = Serial.read(); Serial.write(lee); //Imprime el caracter Serial.print(" = "); Serial.println(lee); //Imprime el codigo ASCCI del caracter } } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] 8m9mphxegj5ahcorm6o8ydi19qotxte 0 329 3565 3529 2019-05-06T17:51:09Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Obtiene el número de bytes (caracteres) disponibles para la escritura (pendientes de ser enviados) en el buffer serie sin bloquear la operación de escritura. == Sintaxis == <pre> Serial.availableForWrite(); Serial1.availableForWrite(); - solo MEGA Serial2.availableForWrite(); - solo MEGA Serial3.availableForWrite(); - solo MEGA </pre> == Retorna == El número de bytes disponibles para escribir ([[int]]). == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] jxthw0wz0fti9aifat66b76ezavktt2 0 292 4798 4458 2019-07-18T17:09:01Z Kike GL 2 wikitext text/x-wiki Abre el puerto serie y fija la velocidad en baudios para la transmisión de datos en serie. El valor típico de velocidad para comunicarse con una computadora es 9600, aunque otras velocidades pueden ser soportadas: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200. {{Nota|No obstante, puede especificar otras velocidad de comunicación a través de los pines 0 (Tx) y 1 (Tx) en [[UNO]], por ejemplo con un componente que requiere una velocidad en baudios particular.}} El valor predeterminado es 8N1 (8 bits de datos, sin paridad, un bit de parada). Pero con este parámetros se pueden configurar otras opciones. == Sintaxis == <pre> Serial.begin(velocidad [, configuracion]); Serial.begin(velocidad, configuracion, Rx, Tx); //ESP8266 </pre> == Parámetros == ;velocidad: Debes usar uno de estos valores 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200. ;configuración: El valor predeterminado es 8N1 (8 bits de datos, sin paridad, un bit de parada). Pero con este parámetros se pueden configurar otras opciones. {|class="wikitable col1cen col2cen col3cen col4cen" |+Configuración serie !Código!!Datos!!Paridad!!Parada |- |5N1||5||rowspan=8|Ninguna||rowspan=4|1 |- |6N1||6 |- |7N1||7 |- |8N1||8 |- |5N2||5||rowspan=4|2 |- |6N2||6 |- |7N2||7 |- |8N2||8 |- |5E1||5||rowspan=8|Par||rowspan=4|1 |- |6E1||6 |- |7E1||7 |- |8E1||8 |- |5E2||5||rowspan=4|2 |- |6E2||6 |- |7E2||7 |- |8E2||8 |- |5O1||5||rowspan=8|Impar||rowspan=4|1 |- |6O1||6 |- |7O1||7 |- |8O1||8 |- |5O2||5||rowspan=4|2 |- |6O2||6 |- |7O2||7 |- |8O2||8 |} ;Rx:Pin de recepción ;Tx:Pin de transmisión == Retorno == Nada. == Comentarios == Nada. == Advertencia == * Aunque es posible poner la velocidad en 115200 si envías muchos datos se perderán algunos a esta velocidad. * Cuando se usa la comunicación serie los puertos digital 0 (Rx) y 1 (Tx) no puede usarse al mismo tiempo. * Para uC a 16 MHz, es posible iniciar una comunicación serial de hasta 2 Mbps (2000000 bps); sin embargo no se recomienda ya que es prácticamente imposible evitar pérdidas a esta velocidad. == Ejemplo 1 == Este ejemplo imprime por consola los numero de 0 a 254 y para. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); for (byte n=0; n<255; n++){ Serial.println(n); } } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == Al iniciar la comunicación serie es posible comprobar si existe el puerto serie que devolverá una verdadero o falso según el caso. Luego de la comprobacion imprime por consola los caracteres ASCII desde el 33 al 126. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(38400); while (!Serial){ ; //Esperar a que se conecte el puerto serie. } for (char n=33; n<127; n++){ Serial.println(n); } } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias extrenas == [[Category:Serial]] df4i6usvb48smlrh1vkaiugzcw0stuo 0 309 3557 3556 2019-05-06T17:48:15Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripcion == Desactiva la comunicación serial, permitiendo que los pines RX y TX se usen para entrada y salida general. Para volver a habilitar la comunicación en serie, llame a [[Serial.begin()]]. == Sintaxis == <pre> Serial.end(); </pre> == Retorna == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); delay(50); Serial.println("Todo listo para comunicar por puerto serie."); Serial.println("Ahora lo cerramos..."); Serial.end(); } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Serial]] mi6rgwyihq6c25mu7b6qb3bfferx88x 0 322 3547 3546 2019-05-06T17:45:32Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Lee datos del buffer serial hasta que se encuentra el caracter o la cadena objetivo de longitud dada; o se agote el tiempo de espera. == Sintaxis == <pre> Serial.find(caracter); Serial.find(cadena); Serial.find(buffer, lon); </pre> == Parametros == ;caracter: caracter a buscar ([[char]]). ;cadena: cadena de caracteres [[string]] a buscar. ;buffer: vector/matriz/secuencia de bytes ([[byte]]*) a buscar. ;lon: la longitud del anterior ([[int]]). == Retorna == Lo que devuelve es un [[bool]]. La función devuelve '''true''' si se encuentra la cadena objetivo, '''false''' si se agota el tiempo de espera sin encontrarla. == Advertencias == * La comparación es binaria; eso quiere decir que, para efectos de cadenas de caracteres, la búsqueda es sensible a las mayúsculas. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte car = Serial.peek(); //Lee carácter enviado y NO borra del buffer. Serial.write(car); //Imprime siempre lo mismo } } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] sb2s51ipffe0mcgwjgtiwkorue0u99f 0 328 3554 3514 2019-05-06T17:47:31Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Lee datos del buffer serial hasta que: *Se encuentre la cadena objetivo. *Se encuentre la cadena terminadora. *Se agote el tiempo de espera. == Sintaxis == <pre> Serial.findUntil(target, terminal); Serial.findUntil(bufObj, lonObj, bufTer, lonTer); </pre> == Parametros == ;target: la cadena a buscar ([[string]]). ;terminal: la cadena terminadora ([[string]]). ;bufObj: vector/matriz/secuencia de bytes ([[byte]]*) a buscar. ;lonObj: longitud de la secuencia objetivo ([[int]]). ;bufTer: vector/matriz/secuencia de bytes ([[byte]]*) terminadora. ;lonTer: longitud de la secuencia terminadora ([[int]]). == Retorna == La función devuelve ([[bool]]) '''true''' si se encuentra la cadena de destino; '''false''' si supera el tiempo de espera sin encontrarla, o se encuentra la cadena terminadora primero. == Advertencias == * La comparación es binaria; eso quiere decir que, para efectos de cadenas de caracteres, la búsqueda es sensible a las mayúsculas. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] akdaq99pky1l600ua1viy89ydb4sx07 0 324 3553 3523 2019-05-06T17:47:17Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Espera a que se complete la transmisión de los datos salientes. == Sintaxis == <pre> Serial.flush(); </pre> == Parametros == Nada. == Retorna == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte car = Serial.peek(); //Lee carácter enviado y NO borra del buffer. Serial.write(car); //Imprime siempre lo mismo } } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] mid7neu7bwz48bybs34ux41mhpgagod 0 321 3552 3551 2019-05-06T17:47:03Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Retorna el tiempo de espera (en milisegundos) actualmente configurado para el puerto serial. == Sintaxis == <pre> Serial.getTimeout() </pre> == Retorna == El tiempo de espera actualmente configurado (en milisegundos como [[unsigned long]]). == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> Serial.print(F("El tiempo de espera actual es de ")); Serial.print(Serial.getTimeout()); Serial.println(F(" ms.")); </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] ag07jshs7lxfs21y3zp6sgjem3h4qud 0 331 5090 5089 2019-10-18T22:41:45Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Busca el siguiente número punto flotante entre los datos entrantes, asumiendo que está codificado como texto y que el separador decimal es un punto ('.'). Se rige bajo las siguientes reglas: * Los caracteres iniciales que no son dígitos o un signo menos, se saltan. * El análisis se detiene cuando el tiempo de espera se agota, o se lee un caracter que no es dígito (excluyendo el ignorado y el punto si es el primer encuentro). * Si no se leyeron dígitos válidos durante el tiempo de espera (vea [[Serial.setTimeout()]]), se devuelve '''0.0'''. == Sintaxis == <pre> Serial.parseFloat(); Serial.parseFloat(caracter); </pre> == Parámetros == ;caracter: caracter a ignorar una vez iniciado el proceso ([[char]]). == Retorna == Retorna un numero tipo [[float]], o '''0.0''' si no encuentra nada. == Advertencias == * Si de parámetro se introduce el símbolo de menos ('-'), el valor retornado nunca será negativo. * Si de parámetro se introduce el punto ('.'), la función fallará en reconocer las cifras decimales. * Este parámetro es muy útil para ignorar coma (',') en números como: 10,000. == Ejemplo 1 == <syntaxhighlight lang="c++"> 1.23 --> 1.23 a1.23 --> 1.23 1.23a --> 1.23 1a2b3 --> 1.00, 2.00 y 3.00 </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ float num = Serial.parseFloat(); Serial.println(num, 2); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] 2d6wue3yq2c76h1mfn3o2ei5f9bixn3 0 330 4517 4516 2019-06-25T21:20:38Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Busca el siguiente número entero entre los datos entrantes, asumiendo que está codificado como texto. Se rige bajo las siguientes reglas: * Los caracteres iniciales que no son dígitos o un signo menos, se saltan. * El análisis se detiene cuando el tiempo de espera se agota, o se lee un caracter que no es dígito (excluyendo el ignorado). * Si no se leyeron dígitos válidos durante el tiempo de espera (vea [[Serial.setTimeout()]]), se devuelve 0. == Sintaxis == <pre> Serial.parseInt(); Serial.parseInt(caracter); </pre> == Parametros == ;caracter: caracter a ignorar una vez iniciado el proceso ([[char]]). == Retorna == Devuelve un número tipo [[long]], o '''0''' si no encuentra nada. == Advertencias == * Si de parámetro se introduce el símbolo de menos ('-'), el valor retornado nunca será negativo. * Este parámetro es muy útil para ignorar coma (',') en números como: 10,000. == Ejemplo 1 == <syntaxhighlight lang="c++"> 123 --> 123 a123 --> 123 123a --> 123 1a2a3 -->1, 2 y 3 </syntaxhighlight> == Ejemplo 2 == En este ejemplo mete uno a uno los dígitos entre 0~9 en monitor serie. <syntaxhighlight lang="c++"> byte x; int y; void setup(){ Serial.begin(115200); } void loop(){ if (Serial.available()){ x = Serial.peek(); y = Serial.parseInt(); Serial.print(x); //ASCII Serial.print(" = "); Serial.println(y); //Entero } } </syntaxhighlight> == Ejemplo 3 == Implementacion de un '''buffer circular''' que se usa para almacenar los ultimos n valores recibidos para efectos de hacer un promedio por ejemplo. <syntaxhighlight lang="c++"> const byte ventana = 5; int circularBuffer[ventana]; byte indice = 0; //Indice circular //Mete nuevo "valor" al buffer circular void meter(int valor){ circularBuffer[indice] = valor; indice++; if (indice >= ventana){ indice = 0; } } void setup(){ Serial.begin(115200); } void loop(){ if (Serial.available()){ int x = Serial.parseInt(); meter(x); for (byte n=0; n<ventana; n++){ Serial.print(circularBuffer[n]); Serial.print(","); } Serial.println(); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == * [https://www.luisllamas.es/buffer-circular-arduino/ Buffer circulare en Arduino] - Luis Llamas [[Category:Serial]] 50okdb8rt23pajl9d6qlzyray5ciwjf 0 332 4514 3568 2019-06-25T01:00:11Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Devuelve el siguiente byte (carácter) de los datos en serie entrantes sin eliminarlo del buffer serie interno. Es decir, las llamadas sucesivas a '''Serial.peek()''' devolverán el mismo carácter, al igual que la próxima llamada a [[Serial.read()]]. == Sintaxis == <pre> Serial.peek(); </pre> == Parametros == Nada. == Retorna == El valor recuperado según el número de bits de datos configurado, o -1 si el buffer de entrada está vacío ([[int]]). == Advertencias == * Si por error no se verifica de antemano si hay datos disponibles, '''peek()''' retornará 255 para [[byte]] en el caso que el valor real sea -1 (nada). == Ejemplo == En este ejemplo debes meter caracteres en el monitor serie, pero siempre veras el primero. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); } void loop(){ if (Serial.available()){ byte car = Serial.peek(); //Lee caracter enviado y NO borra del buffer. Serial.write(car); //Imprime siempre lo mismo, caracter Serial.print(" = "); Serial.println(car); //Imprime siempre lo mismo, código ASCII } } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] hiodp5m4yj6i8p5tg65jzydhu1zykzy 0 287 4813 4808 2019-07-19T00:07:02Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Vuelca o envía un dato (variable, número o cadena), al puerto serie; lo hace mediante la representación textual de su valor. Dicho comando puede tomar diferentes formas, dependiendo de los parámetros que usemos para definir el formato de volcado de los datos. == Sintaxis == <pre> Serial.print("texto a mostrar"); Serial.print(variable [,formato]); Serial.print(variable [,decimales]); </pre> == Parámetros == ;Variable: variable a evaluar. Esta variable puede ser de cualquier tipo. ;formato: por defecto es DEC, pero puedes también usar [[DEC / BIN / HEX / OCT|HEX, OCT o BIN]]. ;digitos: si la variable es tipo [[float]] o [[double]] se puede especificar el numero de decimales. == Retorna == size_t ([[long]]):print() devuelve el número de bytes escritos, aunque leer ese número es opcional. == Advertencias == * Es posible que '''print()''' muestre varios valores al mismo tiempo pero estos deben ser [[suma|concatenados]] en una variable [[String]] previamente. Ver ejemplo 2. == Comentarios == Los literales de caracteres y cadenas también pueden representar caracteres especiales que son difíciles o imposibles de expresar de otra manera en el código fuente de un programa, como "nueva linea" (\n) o "tab" (\t). Estos caracteres especiales son todos precedidos por un carácter de barra diagonal inversa (\). {| class="wikitable col1cen" |+Codigos de escape !Código!!Descripción!!ASCII!!DEC |- |\n||nueva línea||LF||10 |- |\r||retorno de carro||CR||13 |- |\t||tabulacion horizontal||HT||9 |- |\v||tabulacion vertical||VT||11 |- |\b||retroceso||BS||8 |- |\f||salto de página||FF||12 |- |\a||alerta (pitido)||BELL||7 |- |\'||comilla simple||'||39 |- |\"||comillas dobles||"||34 |- |\?||signo de interrogación||?||63 |- |\\||barra invertida||\||47 |} == Ejemplo 1 == Observa que <b>no hay diferencia</b> entre usar [[Serial.write()]] y '''print()''' para un [[char]]. <syntaxhighlight lang="c++"> char c = 'A'; //Serial lo mismo que c = 65 Serial.write(c); //A Serial.print(c); //A Serial.print(c, DEC); //65 Serial.print(c, HEX); //41 Serial.print(c, OCT); //101 Serial.print(c, BIN); //01000001 Serial.print('L', DEC) //76 Serial.print(76, HEX) //4C Serial.print(76, OCT) //114 Serial.print(76, BIN) //01001100 </syntaxhighlight> == Ejemplo 2 == Observa la <b>diferencia sustancial</b> entre usar [[Serial.write()]] y '''print()''' para un [[byte]]. <syntaxhighlight lang="c++"> byte c = 'A'; //Seria lo mismo con c = 65 Serial.write(c); //A Serial.print(c); //65 ***ojo al piojo*** Serial.print(c, DEC); //65 Serial.print(c, HEX); //41 Serial.print(c, OCT); //101 Serial.print(c, BIN); //1000001 </syntaxhighlight> == Ejemplo 3 == En este ejemplo demostramos que a una cadena se le puede '''concatenar''' un numero sin problemas. <syntaxhighlight lang="c++"> Serial.print("Sensor: " + analogReda(A0)); //No muestra nada int sensor = analogRead(A0); sensor = "Sensor: "+ sensor; Serial.print(sensor); //Solo sale valor de analogRead(A0) String sensor = "Sensor: "; sensor = sensor + analogRead(A0); //También puedes usar sensor.concat(analogRead(A0)); Serial.print(sensor); //Ok </syntaxhighlight> == Ejemplo 4 == Aquí un ejemplo mas completo para dejar clara la diferencia entre [[Serial.write()]], '''Serial.print()''' y [[Serial.println()]] <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); Serial.println("*** Estamos listo ***"); } void loop() { if (Serial.available()){ byte ent = Serial.read(); Serial.print("El caracter enviado fue: "); Serial.write(ent); Serial.print(" y su codigo ASCCI es: "); Serial.print(ent); Serial.print(" en HEXADECIMAL es: "); Serial.print(ent, HEX); } } </syntaxhighlight> == Ejemplo 5 == Puede pasar cadenas almacenadas en memoria [[flash]] a '''Serial.print()''' envolviéndolas con el macro [[F()]]. <syntaxhighlight lang="c++"> Serial.print(F("Apuntes de Arduino")); </syntaxhighlight> {{Tip|Esto es muy útil cuando se tiene que enviar gran cantidad de texto que de otro modo usaría mucha [[SRAM]].}} == Ejemplo 6 == Si tienes un [[float]] o un [[double]] puedes especificar el numero de decimales. <syntaxhighlight lang="c++"> Serial.println(PI, 2); //3.14 Serial.println(PI, 6); //3.141593 </syntaxhighlight> == Ejemplo 7 == Podemos usar la [[Asignación condicional]] dentro de print() <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); for (byte n=2; n<14; n++){ pinMode(n, INPUT); } } void loop(){ for (byte n=2; n<14; n++){ Serial.print(n); Serial.print(" = "); Serial.println(digitalRead(n)?"Prendido":"Apagado"); } Serial.println("---------"); delay(1000); } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == * [https://aprendiendoarduino.wordpress.com/tag/comunicacion-serie/ Comunicación serie] - Enrique Crespo * [https://arduino.stackexchange.com/questions/10088/what-is-the-difference-between-serial-write-and-serial-print-and-when-are-they Difference between serial write and serial print] - Stack Exchange [[Category:Serial]] ac9b9lk9s2bl3lxudblcop0h287sixj 0 288 5085 5084 2019-10-14T22:22:42Z Kike GL 2 /* Comentarios */ wikitext text/x-wiki == Descripcion == Vuelca o envía textualmente el valor de una cadena de carateres o variable al puerto serie, seguido de un carácter de retorno de carro "CR" (ASCII 13, o '\r') y un carácter de salto de línea "LF"(ASCII 10, o '\n'). Toma la misma forma que el comando [[Serial.print()]]. == Sintaxis == <pre> Serial.println(); Serial.println("Texto a mostrar"); Serial.println(variable[, formato]); Serial.println(variable[, decimales]); </pre> == Parámetros == ;variable: variable a evaluar. ;formato: por omision es DEC, pero también puede ser [[DEC / BIN / HEX / OCT|HEX, OCT o BIN]]. ;decimales: eliges el numero de decimales a mostrar de una variable tipo [[float]] También se puede prescindir de parámetros, sería para solamente crear el salto de línea. == Retorna == size_t ([[long]]): '''println()''' devuelve el número de bytes escritos, aunque leer ese número es opcional. == Comentarios == Los literales de caracteres y cadenas también pueden representar caracteres especiales que son difíciles o imposibles de expresar de otra manera en el código fuente de un programa, como "nueva linea" (\n) o "tab" (\t). Estos caracteres especiales son todos precedidos por un carácter de barra diagonal inversa (\). {| class="wikitable col1cen" |+Codigos de escape !Código!!Descripción!!ASCII!!DEC |- |\n||nueva línea||LF||10 |- |\r||retorno de carro||CR||13 |- |\t||tabulacion horizontal||HT||9 |- |\v||tabulacion vertical||VT||11 |- |\b||retroceso||BS||8 |- |\f||salto de página||FF||12 |- |\a||alerta (pitido)||BELL||7 |- |\'||comilla simple||'||39 |- |\"||comillas dobles||"||34 |- |\?||signo de interrogación||?||63 |- |\\||barra invertida||\||47 |} == Advertencias == Nada == Ejemplo 1 == <syntaxhighlight lang="c++"> Serial.println("ArduWiki"); //ArduWiki Serial.println(digital(13)); //Imprime 0 o 1. Serial.println(analogRead(A0)); //Imprime entre 0~1024. float n = 1.23456; Serial.println(n); //Imprime 1.23456 Serial.println(n, 0); //Imprime 1 Serial.println(n, 2); //Imprime 1.23 Serial.println(n, 4); //Imprime 1.2345 </syntaxhighlight> == Ejemplo 2 == En este ejemplo demostramos que a una cadena se le puede '''concatenar''' un numero sin problemas. <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); } void loop(){ if (Serial.available()){ String m = "ASCII: "; m = m + Serial.read(); Serial.println(m); } } </syntaxhighlight> == Ejemplo 3 == Podemos usar la [[Asignación condicional]] dentro de println() <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); for (byte n=2; n<14; n++){ pinMode(n, INPUT); } } void loop(){ for (byte n=2; n<14; n++){ Serial.print(n); Serial.print(" = "); Serial.println(digitalRead(n)?"Prendido":"Apagado"); } Serial.println("---------"); delay(1000); } </syntaxhighlight> == Vea tambien == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] bazx6ayxjf6vzcqs1zh48ztyyow2nfq 0 294 4940 4939 2019-09-21T15:31:48Z Kike GL 2 /* Ejemplo 5 */ wikitext text/x-wiki == Descripción == Lee o captura un byte (un carácter) desde el puerto serie. {{Nota|Lo que lee es un caracter en codigo ASCII.}} == Sintaxis == <pre> char variable = Serial.read(); </pre> == Parametros == ;variable: variable para capturar [[char]] o [[byte]] de entrada. Cuidado no es lo mismo ver ejemplos 1 y 2. == Retorno == El valor recuperado según el número de bits de datos configurado, o -1 si el buffer de entrada está vacío ([[int]]). == Advertencia == * Si por error no se verifica de antemano si hay datos disponibles, '''read()''' retornará 255 para [[byte]] en el caso que el valor real sea -1 (nada). * El buffer en el caso de [[UNO]] y [[NANO]] es de 64 kB. Aunque esto se puede cambiar con la libreria '''HardwareSerial.h'''. * El monitor serie '''nunca''' añade a la cadena escrita CR (\n) ni LF (\n) si haces un simple '''Enter'''. No asi si lo escribes en un block de notas y lo copias en la linea de envio. == Ejemplo 1 == En este primer ejemplo usamos una variable tipo [[char]] para capturar el caracter. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ //Espera carácter char car = Serial.read(); //Lee carácter enviado y lo borra del buffer Serial.println(car); //Imprime carácter enviado } } </syntaxhighlight> Si envias A se imprime A, si envias 1 se imprime 1. == Ejemplo 2 == En este segundo ejemplo usamos una variable tipo [[byte]] para capturar carácter. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ //Espera carácter byte car = Serial.read(); //Lee carácter enviado y lo borra del buffer Serial.write(car); //Imprime carácter enviado Serial.print(" = "); Serial.println(car); //Imprime código ASCII carácter enviado } } </syntaxhighlight> Si envias A se imprime 65, si envias 1 se imprime 49. {{Tip|Nota que la única diferencia es que en el ejemplo 1 capturamos como [[char]] y en el segundo ejemplo como [[byte]].}} == Ejemplo 3 == En este ejemplo capturaremos varios caracteres y los almacenamos uno a uno en una variable tipo [[String]]. <syntaxhighlight lang="c++"> String frase = ""; void setup(){ Serial.begin(9600); } void loop(){ while (Serial.available()){ char caracter = Serial.read(); frase.concat(caracter); delay(10); } if (frase != ""){ Serial.println(frase); frase = ""; } } </syntaxhighlight> == Ejemplo 4 == Este ejemplo recibe una matriz de [[int]]s. <syntaxhighlight lang="c++"> int datos[10]; void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available() >= 10 * sizeof(datos[0])){ Serial.readBytes((byte*)datos, 10 * sizeof(datos[0])); } } </syntaxhighlight> == Ejemplo 5 == Mucha gente intenta probar este código enviando datos por el monitor serie y no le funciona, porque el '''Enter''' del monitor serie ejecuta la acción de enviar sin introducir los códigos [[ASCII table|ASCII]] CR (\r) ni LF (\n). <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ String data = Serial.readStringUntil('\n'); Serial.println(data); } } </syntaxhighlight> {{Nota|Para que te funcione este código escribe algo y le das enter (CR) en un Notepad++ por ejemplo y luego copia esa cadena completa y la pegas en el monitor serie y envías.}} == Ejemplo 6 == Si leemos el buffer vacio notamos que la respuesta en -1. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); delay(1000); Serial.println(Serial.read()); } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/functions/communication/serial/print/ Seril.print()] - Referencias Arduino * [https://aprendiendoarduino.wordpress.com/tag/comunicacion-serie/ Comunicacion serie] - Enrique Crespo * [https://www.luisllamas.es/cadenas-de-texto-puerto-serie-arduino/ Cadena de texto por puerto serie] - Luis Llamas * [https://www.luisllamas.es/array-puerto-serie-arduino/ Matriz por puerto serie] - Luis Llamas * [http://manueldelgadocrespo.blogspot.com/p/serialprint.html Serial.print()] - Manuel Delgado * [https://hetpro-store.com/TUTORIALES/arduino-serial-print/ Serial print] - HetPRO * [http://cursoarduinomega.blogspot.com/2015/10/todo-sobre-serialprint.html Serial.print()] - Curso sobre Arduino MEGA * [https://arduino.stackexchange.com/questions/10088/what-is-the-difference-between-serial-write-and-serial-print-and-when-are-they Difference between Serial.print() and Seria.write()] - Stack Exchange [[Category:Serial]] mzny47o6ex0aax8j7hnojbkgovoxc0g 0 325 4511 4510 2019-06-25T00:33:00Z Kike GL 2 /* Ejemplo 2 */ wikitext text/x-wiki == Descripción == Lee caracteres desde el búfer del puerto serie, hacia el especificado. La función termina si la longitud determinada se ha leído, o el tiempo de espera (ver [[Serial.setTimeout()]]) se ha agotado. == Sintaxis == <pre> Serial.readBytes(buffer, largo); </pre> == Parámetros == ;buffer: el buffer/vector/matriz para almacenar los bytes ([[char]]* o [[byte]]*). ;largo: el número de bytes a leer ([[int]]). == Retorna == Devuelve el número de caracteres colocados en el búfer ([[int]]). Un 0 significa que no se encontró nada durante el tiempo de espera. == Advertencias == * La longitud del buffer debe respetarse, de lo contrario se corre el riesgo de un "desbordamiento de buffer" que puede corromper el contenido la memoria de ejecución ([[SRAM]]). == Ejemplo 1 == Hay que recordar que el puerto serie transmite caracteres ASCII. Asi por ejemplo si enviamos 23 la respuesta sera 50 y 51. <syntaxhighlight lang="c++"> byte ref[2]; void setup(){ Serial.begin(115200); } void loop(){ if (Serial.available() > 2){ Serial.readBytes(ref, 2); Serial.println(ref[0]); Serial.println(ref[1]); } } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> if (Serial.available()) { buffer[Serial.readBytes(buffer, sizeof(buffer) - 1)] = 0; // Colocar el terminador de cadenas de caracteres Serial.print(F("Mensaje recuperado: \"")); Serial.print(buffer); Serial.println('\"'); } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] shqq3jxvnycz0kb42bouqy16e53892h 0 326 3564 3563 2019-05-06T17:50:49Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Lee caracteres desde el búfer del puerto serie, hacia el especificado. La función termina si la longitud determinada se ha leído, se ha encontrado el caracter terminador (no lo incluye en la lectura pero sí lo descarta del buffer de entrada del puerto), o el tiempo de espera (ver [[Serial.setTimeout()]]) se ha agotado. == Sintaxis == <pre> Serial.readBytesUntil(caracter, buffer, largo); </pre> == Parametros == ;caracter: el caracter terminador ([[char]]). ;buffer: el buffer/vector/matriz para almacenar los bytes ([[char]]* o [[byte]]*). ;largo: el número de bytes a leer ([[int]]). == Retorna == Devuelve el número de caracteres colocados en el búfer ([[int]]). Un 0 significa que no se encontró nada durante el tiempo de espera o antes del terminador. == Advertencias == * La longitud del buffer debe respetarse, de lo contrario se corre el riesgo de un "desbordamiento de buffer" que puede corromper el contenido la memoria de ejecución ([[SRAM]]). == Ejemplo == <syntaxhighlight lang="c++"> if (Serial.available()) { buffer[Serial.readBytesUntil('\r', buffer, sizeof(buffer) - 1)] = 0; // Colocar el terminador de cadenas de caracteres Serial.read(); // Descarta el '\n' que suele venir con el '\r' Serial.print(F("Linea de texto leida: \"")); Serial.print(buffer); Serial.println('\"'); } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] 1koajs1hjrp29cyzyrbx66wii3iic5f 0 327 3559 3525 2019-05-06T17:49:06Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Lee caracteres y los coloca en un [[String]]. La función finaliza cuando el tiempo de espera (ver [[Serial.setTimeout()]]) se ha agotado. == Sintaxis == <pre> Serial.readString(); </pre> == Retorna == El objeto [[String]] resultante de la lectura. == Advertencias == * Hay un "bug" o fallo con esta función: si el flujo de entrada es constante (tiempo de espera nunca se agota), se corre el riesgo de colgar completamente el programa. La razón se debe a que, conceptualmente, [[String]] es ilimitado en tamaño; pero como la [[SRAM]] no es así, eventualmente el programa llegará a colapsar. == Ejemplo 1 == Envíe por la consola un mensaje corto. Por ejemplo "Hola mundo" <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()) { Serial.print("Mensaje recuperado: \""); Serial.print(Serial.readString()); Serial.println('\"'); } } </syntaxhighlight> == Ejemplo 2 == Envíe por la consola un mensaje corto. Por ejemplo "Hola mundo" <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()) { string texto = Serial.print(Serial.readString(); Serial.println(texto.lenght()); } } </syntaxhighlight> == Ejemplo 3 == En este ejemplo debes enviar una frase por la consola por ejemplo "Apuntes de Arduino". <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()) { String texto = Serial.readString(); Serial.println(texto.length()); } }</syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] byrluia51rqnpx4rd98ysm6eou55vmn 0 323 3571 3527 2019-05-06T17:53:56Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Lee caracteres y los coloca en un [[String]]. La función termina si se ha encontrado el caracter terminador (no lo incluye en la lectura pero sí lo descarta del buffer de entrada del puerto), o el tiempo de espera (ver [[Serial.setTimeout()]]) se ha agotado. == Sintaxis == <pre> Serial.readStringUntil(caracter); </pre> == Parametros == ;caracter: el caracter terminador ([[char]]). == Retorna == El objeto [[String]] resultante de la lectura. == Comentario == Esta función es parte de la clase [[Stream]] y se puede usar cualquier clase que herede de ella ([[Wire]], [[Serial]], etc.). == Advertencias == * Hay un "bug" o fallo con esta función: si el flujo de entrada es constante (tiempo de espera nunca se agota) y nunca se encuentra el caracter terminador, se corre el riesgo de colgar completamente el programa. La razón se debe a que, conceptualmente, [[String]] es ilimitado en tamaño; pero como la [[SRAM]] no es así, eventualmente el programa llegará a colapsar. == Ejemplo 1 == <syntaxhighlight lang="c++"> if (Serial.available()) { Serial.print(F("Linea de texto leida: \"")); Serial.print(Serial.readStringUntil('\r')); // Ojo con el tamaño, que puede que de aquí no pase u ocurra comportamiento indefinido. Serial.println('\"'); Serial.read(); // Descarta el '\n' que suele venir con el '\r' } </syntaxhighlight> == Ejemplo 2 == Es este ejemplo se lee el buffer hasta encontrar el CR+LF. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); } void loop(){ if (Serial.available()) { Serial.println(Serial.readStringUntil("\r\n")); } } </syntaxhighlight> == Ejemplo 3 == Es este ejemplo se lee el buffer hasta encontrar el el punto seguido. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); } void loop(){ if (Serial.available()) { Serial.println(Serial.readStringUntil(". ")); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == * [http://manueldelgadocrespo.blogspot.com/p/readstringuntil.html readstringuntil()] - Manuel Delgado [[Category:Serial]] nv5h16bzde8pwehif6ukgcdwfdmhov1 0 320 3549 3548 2019-05-06T17:46:04Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Establece los milisegundos máximos para esperar datos en serie al usar: [[Serial.readBytes()]] o [[Serial.readBytesUntil()]]. {{Nota|Por defecto son 1000 milisegundos (1 segundo).}} == Sintaxis == <pre> Serial.setTimeout(tiempo); </pre> == Parametros == ;tiempo: tiendo de espera en milisegundos ([[unsigned long]]). == Retorna == Nada. == Advertencias == * No se debe configurar con un valor excesivamente alto o bajo. Si es muy alto, las funciones bloqueantes fuertemente van a entorpecer la ejecución del programa; si es muy bajo, se puede interrumpir la operación antes de tiempo cuando se usan tasas de baudios bajas. == Ejemplo 1 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); Serial.setTimeout(500); } void loop(){ if (Serial.available()){ byte c = Serial.read(); Serial.println(c); } } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); Serial.setTimeout(50); } void loop(){ if (Serial.available()) { byte frase[20]; size_t t = Serial.readBytesUntil('\n', frase, 20); DEBUG(frase, t) } } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == [[Category:Serial]] 1dpzf2oy0aexjmp1lw4usc6i5xrvf6p 0 293 4814 4809 2019-07-19T00:07:22Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Envia datos binarios ("crudos") al puerto serie. Esta información se envía como un byte o serie de bytes. == Sintaxis == <pre> Serial.write(val); Serial.write(str); Serial.write(buf, len); </pre> == Parametros == ;val: Valor como un solo [[byte]] o variable (el byte menos signficativo en caso de ser más grande). ;str: Cadena como una serie de bytes ([[string]]). ;buf: Matriz enviada como una serie de bytes ([[byte]]*). ;len: Largo de la cadena ([[int]]). == Retorno == La cantidad real de bytes que se enviaron con éxito ([[int]]). == Advertencia == Para enviar los caracteres que representan los dígitos de un número, use la función [[Serial.print()]] en su lugar. == Comentarios == * Todos los datos enviados a través del puerto serie se envían como 0 y 1. La diferencia entre '''write()''' y [[Serial.print()|print()]] es cómo lo que se está enviando se '''interpreta'''. * Otro aspecto a tener en cuenta es que '''write()''' trabaja con byte (8 bits) por eso Serial.write(65); produce lo mismo que Serial.write(321); o Serial.write(577); es decir la letra A que corresponde al ASCII 65 y 321 - 256 = 65. Recuerda 2^8 = 256. * Es distinto usar Serial.write("65"); Serial.write("321"); y Serial.write("577"); que es exactamente igual a Serial.print(65); Serial.print(321); y Serial.print(577);. == Ejemplo 1 == <syntaxhighlight lang="c++"> Serial.write(65); //A Serial.write("65"); //65 Serial.write("Hola mundo"); //Hola mundo n = Serial.write("Hola mundo"); //Retorna el largo de cadena Serial.write(0x48); //H Serial.write(0x45); //E Serial.write(0x4C); //L Serial.write(0x4C); //L Serial.write(0x4F); //O </syntaxhighlight> == Ejemplo 2 == Es importante resaltar la diferencia entre usar '''Serial.write()''' vs [[Serial.print()]] o [[Serial.println()]], mira este ejemplo. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); Serial.write(72); //H Serial.write(79); //O Serial.write(76); //L Serial.write(65); //A Serial.print(72); //72 Serial.print(79); //79 Serial.print(76); //76 Serial.print(65); //65 } void loop(){ //nada } </syntaxhighlight> == Ejemplo 3 == Es importante resaltar la diferencia entre usar '''Serial.write()''' vs [[Serial.print()]] o [[Serial.println()]], mira este ejemplo. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); byte x = 'A'; Serial.write(x); //A Serial.print(" = "); Serial.println(x); //65 código ASCII de A } void loop(){ //nada } </syntaxhighlight> == Ejemplo 4 == Enviar una serie de [[byte]]s por puerto serie. <syntaxhighlight lang="c++"> const byte datos[] = {0,1,2,3,5,7,11,13}; const size_t largo = sizeof(datos)/sizeof(datos[0]); void setup(){ Serial.begin(115200); Serial.write(datos, largo); } void loop(){ //nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == * [https://aprendiendoarduino.wordpress.com/tag/comunicacion-serie/ Comunicación serie] - Enrique Crespo * [https://arduino.stackexchange.com/questions/10088/what-is-the-difference-between-serial-write-and-serial-print-and-when-are-they Difference between serial write and serial print] - Stack Exchange [[Category:Serial]] 1yayjs7lgnvj6lh8xqfkuubucqcjnup 0 238 3748 1008 2019-05-06T22:13:28Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 239 3749 1009 2019-05-06T22:13:49Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 240 3750 1010 2019-05-06T22:14:08Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 241 3751 1011 2019-05-06T22:14:29Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 423 3292 3291 2019-05-04T23:17:32Z Kike GL 2 /* Sintaxis */ wikitext text/x-wiki == Descripción == La librería [https://github.com/dgduncan/SevenSegment SevSeg] de Dean Reading desde el gestor de librerias del [[IDE]]. Admite pantallas de cátodo y ánodo comun y el uso de transistores de conmutación. Se pueden usar pantallas con cualquier número de dígitos y admiten decimales. {{Nota|Debes poner una resistencia limitadora de corriente en cada segmento. Tipicamente 330 ohms. Elija RESISTORS_ON_SEGMENTS en 1 para un brillo óptimo.}} == Placas aplicables == == Sintaxis == <pre> #include <SevSeg.h> SevSeg display; display.begin(modo, numDigits, digitPins, segmentPins); </pre> == Parámetros == ;modo:COMMON_CATHODE, COMMON_ANODE, N_TRANSISTORS, P_TRANSISTORS, NP_COMMMON_CATHODE, NP_COMMMON_ANODE. ;numDigits:Numero de digitos ;digitPins:Pines de los digitos ;segmentPins:PInes de los segmentos {| class="wikitable" |+Configuracion hardware |- ! Texto de encabezado !! Texto de encabezado |- | COMMON_CATHODE || Para display de baja potencia de catodo comun sin interruptores. |- | COMMON_ANODE || Para display de baja potencia de anodo comun sin interruptores. |- | N_TRANSISTORES || Para display de alta potencia con transitor NPN. |- | P_TRANSISTORES || Para display de alta potencia con transitor PNP. |- | NP_COMMMON_CATHODE || Para display de alta potencia de tipo catodo comun. |- | NP_COMMMON_ANODE || Para display de alta potencia de tipo anodo comun. |} == Métodos == {| class="wikitable" |+Metodos libreria SevSeg.h |- ! Método !! Descripción |- | display.begin() || Inicia seven segment |- | display.setBrightness(valor) || Brillo entre 0~100 |- | display.setNumber(num, dec) || Muestra '''num''' con '''dec''' decimales. |- | display.refreshDisplay() || Se debe mostrar repetidamente. |} == Comentarios == == Advertencias == Cuidado hay una librería con el mismo nombre: [https://github.com/sparkfun/SevSeg/ SevSeg] de Sparkfun. No esta en el gestor de librerias. == Ejemplo 1 == Usar 4 display de baja potencia de cátodo común. <syntaxhighlight lang="c++"> #include <SevSeg.h> SevSeg display; //Crea una instancia de un objeto de siete segmentos void setup() { byte numDigits = 4; byte digitPins[] = {2, 3, 4, 5}; //Catodos byte segmentPins[] = {6, 7, 8, 9, 10, 11, 12, 13}; //Anodos display.begin(COMMON_CATHODE, numDigits, digitPins, segmentPins); display.setBrightness(90); //Brillo 0~100 display.setNumber(3141,3); //Muestra '3.141' } void loop(){ display.refreshDisplay(); //Para mostrar numero //delay(5); //Si descomentas esto veras un parpadeo } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] * [https://playground.arduino.cc/Main/SevenSegmentLibrary/ SevSeg library] * [https://playground.arduino.cc/Main/SevenSegmentLibrary/ Seven Segment Library] [[Category:Librerias]] 4gj4650suxcjnbmoqxit86jexv6o7ct 0 229 3713 996 2019-05-06T21:56:42Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Analogico</categorytree> == Referencias == [[Category:Analogico]] 2i9mmc2o0iyv8al1yd55kjmy3kjkj6x 0 416 4633 4343 2019-07-04T16:27:04Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == La librería [https://github.com/PaulStoffregen/SoftwareSerial SoftwareSerial.h] de Paul Stoffregen no esta en el Administrador de librerias del IDE. El hardware Arduino tiene soporte incorporado (via un chip UART) para la comunicación en serie en los pines 0 y 1, pero estos pines también van al conector USB por donde se cargan los [[boceto]]s por lo que es delicado usarlos. El búfer en serie de 64 bytes. Esta libreria permitir la comunicación en serie por otros pines digitales del Arduino, usando un software para replicar la misma funcionalidad. Es posible tener múltiples puertos serie de software con velocidades de hasta 115200 bps. Un parámetro habilita la señalización invertida para dispositivos que requieren ese protocolo. == Placas aplicables == [[UNO]], [[NANO]]... == Sintaxis == <pre> #include <SoftwareSerial.h> SoftwareSerial nombreT(2,3); //Rx,Tx </pre> == Parámetros == ;nombre:Nombre que le asignaras al nuevo puerto serie. ;Rx:Pin digtal para Recibir datos ;Tx:Pin digtal para Transmitar datos == Métodos == {| class="wikitable" |+Metodos disponible con SoftwareSerial.h |- ! Método !! Descripción |- | [[Serial.begin()|begin()]] || Abre el puerto serie, fija su configuración y velocidad de comunicación. |- | [[Serial.available()|available()]] || Indica el numero de bytes/caracteres disponibles para lectura. |- | [[Serial.read()|read()]] || Lee un carácter disponible y lo borra del buffer. |- | [[Serial.peek()|peek()]] || Lee un carácter disponible pero queda disponible en el buffer (no borra). |- | [[Serial.write()|write()]] || Envia datos binarios al puerto serie. |- | [[Serial.flush()|flush()]] || Espera a que la transmisión de datos de salida serie termine. |- | [[Serial.print()|print()]] || Imprime una representación textual de un dato. |- | [[Serial.println()|println()]] || Imprime una representación textual de un dato junto con un salto de línea; o solo este último. |- | [[Serial.overflow()|overflow()]] || Pruebas para ver si se ha producido un desbordamiento de búfer serie de software. Al llamar a esta función, se borra el indicador de desbordamiento, lo que significa que las llamadas posteriores devolverán el valor falso a menos que se haya recibido y descartado otro byte de datos mientras tanto. El búfer serial del software puede contener 64 bytes. |- | listen() || Habilita el puerto serie del software seleccionado para escuchar. Solo un puerto serie de software puede escuchar a la vez; Los datos que lleguen a otros puertos serán descartados. Cualquier dato ya recibido se descarta durante la llamada a listen() (a menos que la instancia dada ya esté escuchando). Devuelve un [[bool]] |- | isListening() || Pruebas para ver si el puerto serie del software solicitado está escuchando activamente. Devuelve un [[bool]] |- | [[Serial.end()|end()]] || Desactiva la comunicacion. Para reactivar usar begin() nuevamente. |} {{Tip|Tenga en cuenta que sólo una instancia '''SoftwareSerial''' puede recibir datos entrantes a la vez (seleccione uno de ellos con la función listen()).}} == Limitaciones == La librería tiene las siguientes limitaciones conocidas: # Si utiliza varios puertos serie de software, solo uno puede recibir datos a la vez. # No todos los pines del [[MEGA]] admiten interrupciones, por lo que solo se puede usar lo siguiente para RX: 10, 11, 12, 13, 14, 15, 50, 51, 52, 53, A8 (62), A9 ( 63), A10 (64), A11 (65), A12 (66), A13 (67), A14 (68), A15 (69). # No todos los pines del [[LEONARDO]] admiten interrupciones, por lo que solo se puede usar lo siguiente para RX: 8, 9, 10, 11, 14 (MISO), 15 (SCK), 16 (MOSI). # En Arduino o Genuino 101, la velocidad máxima de RX actual es 57600 bps # En Arduino o Genuino 101 RX no funciona en Pin 13 {{Nota|Si su proyecto requiere flujos de datos simultáneos, consulte la biblioteca [https://github.com/PaulStoffregen/AltSoftSerial AltSoftSerial] de Paul Stoffregen, que supera una serie de problemas con el SoftwareSerial, pero tiene sus propias limitaciones.}} == Advertencias == * Siempre prefiera el '''hardware serial''' tiene mucho mejor rendimiento. Arduino [[MEGA]] tiene 3 disponibles. * AltSoftSerial puede transmitir y recibir simultanemanete. Consume un temporizador de 16 bits, deshabilita algunos pines PWM. * SoftwareSerial puede tener varias instancias en casi cualquier pin, pero solo 1 puede estar activo a la vez. Tampoco se puede transmitir y recibir al mismo tiempo == Ejemplo 1 == En este ejemplo lo que se reciba por un puesto serie se envía por el otro. <syntaxhighlight lang="c++"> #include <SoftwareSerial.h> SoftwareSerial miSerial(10, 11); //Rx, Tx void setup() { Serial.begin(57600); miSerial.begin(4800); } void loop() { if (miSerial.available()) { Serial.write(miSerial.read()); } if (Serial.available()) { miSerial.write(Serial.read()); } } </syntaxhighlight> == Ejemplo 2 == Aqui un ejemplo de implementacion de bluetooth. <syntaxhighlight lang="c++"> #include <SoftwareSerial.h> SoftwareSerial BT(2,3); //RX,TX void setup() { Serial.begin(115200); //pinMode(4, OUTPUT); //Pin Vcc del HC-05 (On/Off) //pinMode(5, OUTPUT); //Pin KEY del HC-05 (HIGH = AT) //digitalWrite(5, HIGH); //delay(500); //digitalWrite(4, HIGH); BT.begin(9600); Serial.println("Mete comandos AT: "); } void loop() { if (BT.available()){ Serial.write(BT.read()); } if (Serial.available()){ String cadena = ""; char c = Serial.read(); ; while (c != '\n'){ cadena += c ; delay(25) ; c = Serial.read(); } cadena += c ; BT.print(cadena); Serial.println("---> " + cadena); } } </syntaxhighlight> == Ejemplo 3 == Otro ejemplo con el bluetooth. <syntaxhighlight lang="c++"> #include <SoftwareSerial.h> SoftwareSerial BT(2,3); //RX,TX void setup() { Serial.begin(115200); BT.begin(57600); } void loop() { if (BT.available()){ char c = BT.read(); switch (c){ case "A": digitalWrite(10, HIGH); Serial.println("Prende 10"); break; case "a": digitalWrite(10, LOW); Serial.println("Apaga 10"); break; case "B": digitalWrite(11, HIGH); Serial.println("Prende 11"); break; case "b": digitalWrite(11, LOW); Serial.println("Apaga 11"); break; } } if (Serial.available()){ String cadena = ""; char c = Serial.read(); ; while (c != '\n'){ cadena += c ; delay(25) ; c = Serial.read(); } cadena += c ; BT.print(cadena); Serial.println("---> " + cadena); } } </syntaxhighlight> == Ejemplo 4 == Comunicar 2 Arduino UNO por bluetooth. El Maestro tiene un pulsador en pin 9 y cuando se pulse se debe conmutar el LED incorporado en el esclavo. Recuerda que ambos deben usar la misma velocidad (AT+BAUD4) y contraseña (AT+PIN123). Maestro: <syntaxhighlight lang="c++"> #include <SoftwareSerial.h> #include <Bounce2.h> SoftwareSerial BT(2,3); //RX,TX Bounce rebote = Bounce(); void setup(){ BT.begin(9600); pinMode(9, INPUT_PULLUP); rebote.attach(9); rebote.interval(5); } void loop(){ rebote.update(); if (rebote.fell()){ BT.print("1"); } } </syntaxhighlight> Esclavo: <syntaxhighlight lang="c++"> #include <SoftwareSerial.h> SoftwareSerial BT(2,3); //RX,TX void setup(){ BT.begin(9600); pinMode(13, OUTPUT); } void loop(){ if (BT.available()){ char x = BT.read(); if (x 1){ digitalWrite(13, !digitalRead(13)); } } } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] * [https://www.arduino.cc/en/Reference/SoftwareSerial SoftwareSerial] * [https://www.pjrc.com/teensy/td_libs_AltSoftSerial.html AltSoftSerial] de Paul Stoffregen * [http://manueldelgadocrespo.blogspot.com/p/biblioteca.html Software Serial] - Manuel Delgado * [https://aprendiendoarduino.wordpress.com/tag/hc-05/ HC-05] - Enrique Crespo * [https://naylampmechatronics.com/blog/24_configuracion-del-modulo-bluetooth-hc-05-usa.html HC-05] - Naylamp * [http://www.prometec.net/bt-hc06/ HC-06] - Prometec * [http://www.prometec.net/bt-hc05/ HC-05] - Prometec * [http://www.prometec.net/bluetooth-le/ BLE] - Prometec * [http://www.prometec.net/pc-bt/ PC BT] - Prometec * [http://www.prometec.net/android-bt/ Android BT] - Prometec * [http://diymakers.es/arduino-bluetooth/ Arduino Bluetooth] - DiyMarkers [[Category:Librerias]] hx75gav18gwnnx7deu73kyq9wikh5m5 0 156 4674 4673 2019-07-07T01:06:30Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == == Código == <pre> </pre> == Comentarios == == Vea también == <categorytree mode=all>Ejemplo Digital</categorytree> == Referencias externas == [[Category:Ejemplo Digital]] 1v9i19jgpctozhitw3eglayaj8aj8i9 0 297 3638 3637 2019-05-06T18:22:49Z Kike GL 2 /* Referencia */ wikitext text/x-wiki == Descripción == '''Stream''' es la clase base para las secuencias (flujos) de entrada, basadas en caracteres y binarios. No se llama directamente, sino que se invoca cada vez que usa un método (función) que depende de él. Al heredar también de [[Print]], además adquiere la capacidad de ser la base para flujos que a la vez son de salida (bidireccionales). '''Stream''' define las funciones de lectura en Arduino. Al usar cualquier funcionalidad principal que use un [[Serial.read()]] método similar, puede asumir de manera segura que llama a la clase '''Stream'''. Para funciones como [[Serial.print()]], '''Stream''' hereda de la clase '''Print'''. {{Nota|Cuando se crea una clase que requiera de las siguientes funciones (métodos), estas '''DEBEN''' ser implementadas explícitamente: '''read()''', '''peek()''', '''available()''', '''write()''' de un único byte y '''flush()'''. '''availableForWrite()''' es opcional, sin embargo debería implementarse si el flujo de salida es asincrónico (no bloqueante) y byte a byte; no así para transferencias por bloques (ej.: para memorias de almacenamiento masivo como las tarjetas [[SD]]).}} == Sintaxis == <pre> Stream objeto; </pre> == Parámetros == ;objeto: nombre del objeto instancias de la clase '''Stream'''. == Retorna == Nada. == Métodos == {{Nota|'''Stream''' es una clase "abstracta" o "virtual"; a pesar de que no se le pueda referir directamente por su nombre, así se denotará en la siguiente tabla con el propósito de diferenciarse de las subclases.}} {|class="wikitable" |+Métodos de clase Stream !Método!!Descripción |- |[[Stream.setTimeout()]]||Cambia el tiempo de espera (de la llegada de nuevos datos). Por defecto es 1 segundo. |- |[[Stream.getTimeout()]]||Retorna el tiempo de espera actualmente configurado. |- |[[Stream.available()]]||Indica el número de bytes/caracteres disponibles para lectura. |- |[[Stream.read()]]||Lee un carácter/byte disponible. |- |[[Stream.readBytes()]]||Lee uno o más bytes, y los almacena en el buffer/vector/matriz espeficificado. |- |[[Stream.readBytesUntil()]]||Similar al anterior, excepto que con la posibilidad de además finalizar con un terminador. |- |[[Stream.readString()]]||Convierte el flujo de entrada en un objeto [[String]]. |- |[[Stream.readStringUntil()]]||Similar al anterior, excepto que con la posibilidad de además finalizar con un terminador. |- |[[Stream.peek()]]||Lee un carácter disponible, pero no lo descarta del flujo y/o no lo hace "avanzar". |- |[[Stream.write()]]*||Envia datos binarios al flujo de salida. |- |[[Stream.availableForWrite()]]*||Indica el número de bytes que todavía están pendientes de enviarse (no aplica para flujos sincrónicos o por bloques). |- |[[Stream.print()]]*||Imprime (envía), al flujo de salida, una representación textual de un dato. |- |[[Stream.println()]]*||Imprime (envía), al flujo de salida, una representación textual de un dato junto con un salto de línea; o solo este último. |- |[[Stream.flush()]]*||Espera a que todos los bytes se hayan enviado (para flujos byte a byte asincrónicos), o fuerza el envío de estos (para flujos por bloques). |- |[[Stream.find()]]||Lee datos hasta encontrar una coincidencia con una cadena de caracteres o bytes. |- |[[Stream.findUntil()]]||Similar al anterior, excepto que con la posibilidad de además finalizar con una cadena terminadora. |- |[[Stream.parseInt()]]||Convierte el flujo de entrada en un valor entero, asumiendo codificación textual. |- |[[Stream.parseFloat()]]||Convierte el flujo de entrada en un valor punto flotante, asumiendo codificación textual. |} {{Nota|los métodos marcados con '''*''' son los que se heredan de [[Print]].}} == Advertencias == * Para usar un método debe reemplazar la palabra '''Stream''' por el nombre del objeto instanciado. == Comentarios == Esta clase esta presente en las siguientes librerías: * [[Serial]] * [[Wire]] * [[Ethernet]] * [[SD]] {{Nota|A pesar de estas funciones existen en varias implementaciones (ej.: [[Serial]]), su función real puede variar según el contexto de la subclase. Aquí se explicarán de manera generalizada.}}{{Nota|Se entiende por '''flujo sincrónico''' por aquel que no posee buffer y bloquea la ejecución del programa cada vez que se intenta operar sobre este; su opuesto, el '''flujo asincrónico''', sí tiene buffer y no bloquea. Se entiende por '''flujo byte a byte''' o '''flujo de caracteres''' a aquel donde los bytes son recibidos/enviados inmediatamente; mientras que el '''flujo por bloques''' necesariamente debe tener un buffer llamado "caché", y los datos son enviados/recibidos únicamente bajo demanda.}} == Vea también == <categorytree mode=all>Stream</categorytree> == Referencia == [[Category:Stream]] 2lk9j5c8rp8zsysmp2h622e5318p43a 0 299 3539 3538 2019-05-06T17:42:51Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Obtiene el número de bytes disponibles para leer en el flujo de entrada. == Sintaxis == <pre> objetoStream.available(); </pre> == Parámetros == Nada. == Retorno == La cantidad de bytes/caracteres disponibles para lectura ([[int]]). == Advertencias == * Cualquier clase que herede de [[Stream]], debe implementar obligatoria y explícitamente esta función. Debe hacerse de manera que cumpla lo descrito en la sección de '''Descripción''' y '''Retorno'''. == Ejemplo == <syntaxhighlight lang="c++"> void loop(){ if (Serial.available()){ byte lee = Serial.read(); Serial.write(lee); //Imprime el caracter Serial.print(lee, DEC); //Imprime el codigo ASCCI del caracter } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] ragejyxf9y3yhu9qpdkcgtp1w9r69n9 0 361 3664 3663 2019-05-06T18:31:16Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Obtiene el número de bytes (caracteres) disponibles para la escritura (pendientes de ser enviados) hacia el flijo de salida, sin bloquear la operación de escritura. == Sintaxis == <pre> objetoStream.availableForWrite(); </pre> == Parámetros == ;objetoStream: Nombre de la instancia de la clase [[Stream]] == Retorna == El número de bytes disponibles para escribir ([[int]]). == Advertencias == * Si la clase manipula un flujo de salida byte a byte asincrónico (con buffer), esta función debe implementarse y además debe hacerlo de manera que cumpla lo descrito en la sección de '''Descripción''' y '''Retorno'''. Para flujos por bloques, es opcional; pero si se hace, se recomienda que retorne '''0''' si el bloque en caché no necesita transmitirse (solo lectura), o que retorne el tamaño de dicho bloque (en bytes) en el caso contrario. '''No se debe implementar en flujos de salida byte a byte sincrónicos (sin buffer)''''. == Ejemplo == <syntaxhighlight lang="c++"> Serial.write(buffer, 64); // En cierto grado, 64 bytes a la vez es bastante int pendientes = Serial.availableForWrite(); // Si el flujo de salida es lo suficientemente lento, se podrá capturar un valor mayor que cero Serial.flush(); // Esperar a que los datos pendientes se hayan enviado, para así imprimir al final el valor capturado Serial.println(pendientes); </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] 3wd679ju6p5ekpzgcikrtq2xl64dpg0 0 302 3601 3600 2019-05-06T18:06:13Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Lee datos del flujo de entrada hasta que se encuentra el caracter o la cadena objetivo de longitud dada; o se agote el tiempo de espera. == Sintaxis == <pre> objetoStream.find(caracter); objetoStream.find(cadena); objetoStream.find(buffer, lon); </pre> == Parametros == ;objetoStream: nombre de la instancia de la clase [[Stream]] ;caracter: caracter a buscar ([[char]]). ;cadena: cadena de caracteres [[string]] a buscar. ;buffer: vector/matriz/secuencia de bytes ([[byte]]*) a buscar. ;lon: la longitud del anterior ([[int]]). == Retorna == Lo que devuelve es un [[bool]]. La función devuelve '''true''' si se encuentra la cadena objetivo, '''false''' si se agota el tiempo de espera sin encontrarla. == Advertencias == * La comparación es binaria; eso quiere decir que, para efectos de cadenas de caracteres, la búsqueda es sensible a las mayúsculas. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] otdvik2vj2xmjobgt53gjt5khveo5ss 0 303 3650 3649 2019-05-06T18:27:19Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Lee datos del flujo de entrada hasta que: *Se encuentre la cadena objetivo. *Se encuentre la cadena terminadora. *Se agote el tiempo de espera. == Sintaxis == <pre> objetoStream.findUntil(target, terminal); objetoStream.findUntil(bufObj, lonObj, bufTer, lonTer); </pre> == Parametros == ;target: la cadena a buscar ([[string]]). ;terminal: la cadena terminadora ([[string]]). ;bufObj: vector/matriz/secuencia de bytes ([[byte]]*) a buscar. ;lonObj: longitud de la secuencia objetivo ([[int]]). ;bufTer: vector/matriz/secuencia de bytes ([[byte]]*) terminadora. ;lonTer: longitud de la secuencia terminadora ([[int]]). == Retorna == La función devuelve ([[bool]]) '''true''' si se encuentra la cadena de destino; '''false''' si supera el tiempo de espera sin encontrarla, o se encuentra la cadena terminadora primero. == Advertencias == * La comparación es binaria; eso quiere decir que, para efectos de cadenas de caracteres, la búsqueda es sensible a las mayúsculas. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] o4qh819fp6jrk37gh5beaz8vzl07875 0 301 3573 3572 2019-05-06T17:54:40Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Su efecto varía según el tipo de flujo de salida: ;Byte a byte sincrónico (sin buffer): no hace nada. ;Byte a byte asincrónico (con buffer): bloquea la ejecución hasta que todos los datos pendientes hayan sido enviados. ;Por bloques: fuerza el envío del bloque en caché, a menos que no se haya modificado de antemano (con respecto al mismo bloque en la fuente de datos). ;Sin implementar/no soportado: no hace nada. == Sintaxis == <pre> objeto.flush(); </pre> == Parámetros == ;objeto: nombre de la instancia de la clase [[Stream]]. == Retorna == Boleano. == Advertencias == * Cualquier clase que herede de [[Stream]], debe implementar obligatoria y explícitamente esta función. Debe hacerse de manera que cumpla lo descrito en la sección de '''Descripción'''. Debe implementarse de acuerdo al tipo de flujo de salida que maneja. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == * [https://www.arduino.cc/en/Reference/StreamFlush Guia de referencia Arduino] [[Category:Stream]] e6sljb1j39bhdai9b5i2n9su3hcg26j 0 312 3646 3645 2019-05-06T18:26:09Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Retorna el tiempo de espera (en milisegundos) actualmente configurado para el flujo de entrada. == Sintaxis == <pre> objetoStream.getTimeout() </pre> == Parametros == Nada. == Retorna == El tiempo de espera actualmente configurado (en milisegundos como [[unsigned long]]). == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> Serial.print(F("El tiempo de espera actual es de ")); Serial.print(Serial.getTimeout()); Serial.println(F(" ms.")); </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] 6et3a2c0xswb8edn5b65oi9pfhp7aay 0 319 3662 3661 2019-05-06T18:30:46Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Busca el siguiente número punto flotante entre los datos entrantes, asumiendo que está codificado como texto y que el separador decimal es un punto ('.'). Se rige bajo las siguientes reglas: * Los caracteres iniciales que no son dígitos o un signo menos, se saltan. * El análisis se detiene cuando el tiempo de espera se agota, o se lee un caracter que no es dígito (excluyendo el ignorado y el punto si es el primer encuentro). * Si no se leyeron dígitos válidos durante el tiempo de espera (vea [[Stream.setTimeout()]]), se devuelve '''0.0'''. == Sintaxis == <pre> objetoStream.parseFloat(); objetoStream.parseFloat(caracter); </pre> == Parámetros == ;caracter: caracter a ignorar una vez iniciado el proceso ([[char]]). == Retorna == Retorna un numero tipo [[float]], o '''0.0''' si no encuentra nada. == Advertencias == * Si de parámetro se introduce el símbolo de menos ('-'), el valor retornado nunca será negativo. * Si de parámetro se introduce el punto ('.'), la función fallará en reconocer las cifras decimales. == Ejemplo == <syntaxhighlight lang="c++"> Serial.print(F("El doble del número en el archivo es ")); Serial.println(archivo.parseFloat() * 2); // Si todo sale bien, no debería imprimir "0.0" a menos que ese sea realmente el valor recuperado </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] i8xlis58enjmaws5p8uxvpmcr3xkkq2 0 318 3656 3655 2019-05-06T18:28:50Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Busca el siguiente número entero entre los datos entrantes, asumiendo que está codificado como texto. Se rige bajo las siguientes reglas: * Los caracteres iniciales que no son dígitos o un signo menos, se saltan. * El análisis se detiene cuando el tiempo de espera se agota, o se lee un caracter que no es dígito (excluyendo el ignorado). * Si no se leyeron dígitos válidos durante el tiempo de espera (vea [[Stream.setTimeout()]]), se devuelve 0. == Sintaxis == <pre> objetoStream.parseInt(); objetoStream.parseInt(caracter); </pre> == Parametros == ;caracter: caracter a ignorar una vez iniciado el proceso ([[char]]). == Retorna == Devuelve un número tipo [[long]], o '''0''' si no encuentra nada. == Advertencias == * Si de parámetro se introduce el símbolo de menos ('-'), el valor retornado nunca será negativo. == Ejemplo == <syntaxhighlight lang="c++"> Serial.print(F("El doble del número en el archivo es ")); Serial.println(archivo.parseInt() * 2); // Si todo sale bien, no debería imprimir cero a menos que ese sea realmente el valor recuperado </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] 192e70fayiwia41ec6yboiadoj9fswp 0 304 5055 3642 2019-10-07T22:07:32Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Devuelve el siguiente byte (carácter) del flujo de entrada, sin descartar (flujos byte a byte) o avanzar (flujos por bloques). Es decir, las llamadas sucesivas a '''peek()''' devolverán el mismo carácter, al igual que la próxima llamada a [[Stream.read()]]. == Sintaxis == <pre> objetoStream.peek(); </pre> == Retorno == El valor recuperado, o -1 si no hay datos para leer ([[int]]). == Advertencias == * Si por error no se verifica de antemano si hay datos disponibles, '''peek()''' retornará 255 para [[byte]] en el caso que el valor real sea -1 (nada). * Cualquier clase que herede de [[Stream]], debe implementar obligatoria y explícitamente esta función. Debe hacerse de manera que cumpla lo descrito en la sección de '''Descripción''' y '''Retorno'''. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte car = Serial.peek(); //Lee caracter enviado y NO borra del buffer. Serial.write(car); //Imprime siempre lo mismo } } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias externas == [[Category:Stream]] e9jnnmgxgtlha8q0jl3r9bz5k5gaxrl 0 315 3644 3643 2019-05-06T18:25:36Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Vuelca o envía un dato (variable, número o cadena), al puerto serie; lo hace mediante la representación textual de su valor. Dicho comando puede tomar diferentes formas, dependiendo de los parámetros que usemos para definir el formato de volcado de los datos. == Sintaxis == <pre> objetoStream.print("texto a mostrar"); objetoStream.print(variable, formato); </pre> == Parametros == ;variable: variable a evaluar. Esta variable puede ser de cualquier tipo. ;formato: por defecto es '''DEC''', pero puedes también usar '''HEX''', '''OCT''' o '''BIN'''. También puede ser un valor del 0 al 7 si '''variable''' es un punto flotante, representaría la cantidad de cifras decimales a imprimir. También se pueden utilizar cadenas de caracteres en memoria [[flash]], definidas dentro de [[F()]]. == Retorna == La cantidad de caracteres que se llegaron a enviar en el proceso ([[long]]). == Advertencias == Nada. == Comentarios == Los literales de caracteres y cadenas también pueden representar caracteres especiales que son difíciles o imposibles de expresar de otra manera en el código fuente de un programa, como "nueva linea" (\n) o "tab" (\t). Estos caracteres especiales son todos precedidos por un carácter de barra diagonal inversa (\). {| class="wikitable col1cen" |+Codigos de escape !Código!!Descripción |- |\n||nueva línea |- |\r||retorno de carro |- |\t||lengüeta |- |\v||pestaña vertical |- |\b||retroceso |- |\f||alimentación de formulario (alimentación de página) |- |\a||alerta (pitido) |- |\'||comilla simple ( ') |- |\"||comillas dobles ( ") |- |\?||signo de interrogación ( ?) |- |\\||barra invertida ( \) |} == Ejemplo == <syntaxhighlight lang="c++"> Serial.print(F("Fecha de compilacion: ")); Serial.println(F(__DATE__)); Serial.print(F("Hora de compilacion: ")); Serial.println(F(__TIME__)); // __DATE__ y __TIME__ son definiciones implícitas en todo boceto de Arduino; son cadenas de caracteres que represetan la fecha y hora de la compilación del código. // Ya que una definición de cadena equivale a const char*, es aceptado en F() para no consumir RAM. </syntaxhighlight> <syntaxhighlight lang="c++"> byte c = 'A'; //Serial lo mismo que c = 65 Serial.write(c); //A ***ojo al piojo*** Serial.print(c); //65 Serial.print(c, DEC); //65 Serial.print(c, HEX); //41 Serial.print(c, OCT); //101 Serial.print(c, BIN); //1000001 </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] o0pqxpa34i4krkcce35t5o6ssmoqlmt 0 363 3602 1918 2019-05-06T18:07:12Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripcion == Vuelca o envía textualmente el valor de una cadena de caracteres o variable al [[flujo de salida]], seguido de un carácter de retorno de carro "CR" (ASCII 13, o '\r') y un carácter de salto de línea "LF" (ASCII 10, o '\n'). Toma la misma forma que el comando [[Stream.print()]] (donde se dan más detalles respecto a estas funciones). En escencia, agrega "\r\n" al final del texto resultante. == Sintaxis == <pre> objeto.println(); objeto.println("Texto a mostrar"); objeto.println(variable, formato); objeto.println(variable, decimales); </pre> == Parametros == ;objeto: nombre de la instancia de la clase [[Stream]] ;formato: por omision es '''DEC''', pero también puede ser '''HEX''', '''OCT''' o '''BIN'''. ;decimales: eliges el numero de decimales a mostrar de una variable tipo [[float]] == Retorna == La cantidad de caracteres que se llegaron a enviar en el proceso ([[long]]). == Comentario == También se puede prescindir de parámetros, sería para solamente crear el salto de línea. == Advertencias == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); } void loop() { Serial.println(analogRead(A0)); //Se necesita el salto de línea para que funcione correctamente con el serial plotter } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] g455t8ha83xe3iqlzk2l8x41xrj06ni 0 300 3640 3639 2019-05-06T18:24:16Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Lee un byte/caracter proveniente del flujo de entrada; y lo "consume" (flujos byte a byte) o provoca avanzar al siguiente (flujos por bloques). == Sintaxis == <pre> objetoStream.read() </pre> == Parametros == Nada. == Retorno == El valor recuperado, o -1 si no hay datos para leer ([[int]]). == Advertencias == * Si por error no se verifica de antemano si hay datos disponibles, '''read()''' retornará 255 para [[byte]] en el caso que el valor real sea -1 (nada). * Cualquier clase que herede de [[Stream]], debe implementar obligatoria y explícitamente esta función. Debe hacerse de manera que cumpla lo descrito en la sección de '''Descripción''' y '''Retorno'''. == Ejemplo == <syntaxhighlight lang="c++"> void loop(){ if (Serial.available()){ byte car = Serial.read(); //Lee caracter enviado y borra del buffer Serial.write(car); //Imprime caracter enviado Serial.println(car); //Impime codigo ASCII caracter enviado } } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] tn0kc4wsxf7pcjfwzzgwrskaypoixob 0 298 3654 3653 2019-05-06T18:28:23Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Lee caracteres desde el flujo de entrada, hacia el buffer especificado. La función termina si la longitud determinada se ha leído, o el tiempo de espera (ver [[Stream.setTimeout()]]) se ha agotado. == Sintaxis == <pre> objetoStream.readBytes(buffer, largo) </pre> == Parametros == ;objetoStream : una instancia de una clase que hereda de Stream. ;buffer: el búfer para almacenar los bytes en [[char]]* o [[byte]]* ;largo: la cantidad máxima de bytes a leer ([[int]]) == Retorno == Devuelve el número de caracteres colocados en el búfer ([[int]]). Un 0 significa que no se encontró nada durante el tiempo de espera. == Advertencias == * La longitud del buffer debe respetarse, de lo contrario se corre el riesgo de un "desbordamiento de buffer" que puede corromper el contenido la memoria de ejecución ([[SRAM]]). == Ejemplo == <syntaxhighlight lang="c++"> if (Serial.available()) { buffer[Serial.readBytes(buffer, sizeof(buffer) - 1)] = 0; // Colocar el terminador de cadenas de caracteres Serial.print(F("Mensaje recuperado: \"")); Serial.print(buffer); Serial.println('\"'); } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] 2w4tosuugaeh79g7milw1pgv5he61ya 0 314 3660 3659 2019-05-06T18:30:11Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Lee caracteres desde el flujo de entrada, hacia el buffer especificado. La función termina si la longitud determinada se ha leído, se ha encontrado el caracter terminador (no lo incluye en la lectura pero sí lo descarta/ignora del flujo), o el tiempo de espera (ver [[Stream.setTimeout()]]) se ha agotado. == Sintaxis == <pre> objetoStream.readBytesUntil(caracter, buffer, largo); </pre> == Parametros == ;caracter: el caracter terminador ([[char]]). ;buffer: el buffer/vector/matriz para almacenar los bytes ([[char]]* o [[byte]]*). ;largo: el número de bytes a leer ([[int]]). == Retorna == Devuelve el número de caracteres colocados en el búfer ([[int]]). Un 0 significa que no se encontró nada durante el tiempo de espera o antes del terminador. == Advertencias == * La longitud del buffer debe respetarse, de lo contrario se corre el riesgo de un "desbordamiento de buffer" que puede corromper el contenido la memoria de ejecución ([[SRAM]]). == Ejemplo == <syntaxhighlight lang="c++"> if (Serial.available()) { buffer[Serial.readBytesUntil('\r', buffer, sizeof(buffer) - 1)] = 0; // Colocar el terminador de cadenas de caracteres Serial.read(); // Descarta el '\n' que suele venir con el '\r' Serial.print(F("Linea de texto leida: \"")); Serial.print(buffer); Serial.println('\"'); } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] 5gx5sjiwt44geanfg4fv94dfryajpfj 0 316 3666 3665 2019-05-06T18:31:47Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Lee caracteres y los coloca en un [[String]]. La función finaliza cuando el tiempo de espera (ver [[Stream.setTimeout()]]) se ha agotado. == Sintaxis == <pre> objetoStream.readString(); </pre> == Parámetros == ;objetoStream: nombre de la instancia de la clase [[Stream]]. == Retorna == El objeto [[String]] resultante de la lectura. == Advertencias == * Hay un "bug" o fallo con esta función: si el flujo de entrada es constante (tiempo de espera nunca se agota) o lo suficientemente grande, se corre el riesgo de colgar completamente el programa. La razón se debe a que, conceptualmente, [[String]] es ilimitado en tamaño; pero como la [[SRAM]] no es así, eventualmente el programa llegará a colapsar. == Ejemplo == <syntaxhighlight lang="c++"> if (Serial.available()) { Serial.print(F("Mensaje recuperado: \"")); Serial.print(Serial.readString()); // Ojo con el tamaño, que puede que de aquí no pase u ocurra comportamiento indefinido. Serial.println('\"'); } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] 13ifmauunm75ej039u4xz843qo9ry5i 0 317 3658 3657 2019-05-06T18:29:38Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Lee caracteres y los coloca en un [[String]]. La función termina si se ha encontrado el caracter terminador (no lo incluye en la lectura pero sí lo descarta/ignora del flujo), o el tiempo de espera (ver [[Stream.setTimeout()]]) se ha agotado. == Sintaxis == <pre> objetoString.readStringUntil(caracter); </pre> == Parametros == ;caracter: el caracter terminador ([[char]]). == Retorna == El objeto [[String]] resultante de la lectura. == Advertencias == * Hay un "bug" o fallo con esta función: si el flujo de entrada es constante (tiempo de espera nunca se agota) o lo suficientemente grande, y nunca se encuentra el caracter terminador; se corre el riesgo de colgar completamente el programa. La razón se debe a que, conceptualmente, [[String]] es ilimitado en tamaño; pero como la [[SRAM]] no es así, eventualmente el programa llegará a colapsar. == Ejemplo == <syntaxhighlight lang="c++"> if (archivo.available()) { Serial.print(F("Linea de texto leida: \"")); Serial.print(archivo.readStringUntil('\r')); // Ojo con el tamaño, que puede que de aquí no pase u ocurra comportamiento indefinido. Serial.println('\"'); archivo.read(); // Descarta el '\n' que suele venir con el '\r' } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] 5pdbw70k7qffn015obi77p6xu1s7yzt 0 311 3652 3651 2019-05-06T18:27:51Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Asigna un tiempo de espera (en milisegundos) de nuevos datos en el flujo de entrada. '''Para flujos por bloques, esto no debería tener ningún efecto.''' == Sintaxis == <pre> objetoStream.setTimeout(t); </pre> == Parametros == ;t: el tiempo de espera (en milisegundos) a asignar ([[unsigned long]]). == Retorna == Nada. == Advertencias == * No se debe configurar con un valor excesivamente alto o bajo. Si es muy alto, las funciones bloqueantes fuertemente van a entorpecer la ejecución del programa; si es muy bajo, se puede interrumpir la operación antes de tiempo, dependiendo del ritmo del flujo de entrada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); Serial.setTimeout(500); // Esto quiere decir que a lo sumo va a esperar medio segundo por datos nuevos } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] jhv4c4cqi6k609cwwl4mylwu5rcul62 0 313 3648 3647 2019-05-06T18:26:40Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Envia datos binarios ("crudos") al flujo de salida. Esta información se envía como un byte o serie de bytes. == Sintaxis == <pre> objetoStream.write(val); objetoStream.write(str); objetoStream.write(buf, len); </pre> == Parametros == ;val: Valor como un solo [[byte]] o variable (el byte menos signficativo en caso de ser más grande). ;str: Cadena como una serie de bytes ([[string]]). ;buf: Matriz enviada como una serie de bytes ([[byte]]*). ;len: Largo de la cadena ([[int]]). == Retorno == La cantidad real de bytes que se enviaron con éxito ([[int]]). == Advertencias == * Para enviar los caracteres que representan los dígitos de un número, use la función [[Stream.print()]] en su lugar. * Cualquier clase que herede de [[Stream]], debe implementar obligatoria y explícitamente esta función. Debe hacerse de manera que cumpla lo descrito en la sección de '''Descripción''' y '''Retorno'''. En este caso, solo se debe implementar la versión de un sólo byte ('''objetoStream.write(val)'''); y debe retornar '''1''' ([[true / false|true]]) si se pudo transmitir el dato, '''0''' ([[true / false|false]]) en caso contrario. Si la clase no posee o soporta flujos de salida, simplemente debe retornar '''0''' ([[true / false|false]]) para que las operaciones de este tipo no se puedan realizar. == Ejemplo == <syntaxhighlight lang="c++"> while (archivo.available()) { Serial.write(archivo.read()); // Vuelca el contenido "crudo" o binario del archivo, al puerto serial } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == [[Category:Stream]] qo8y5lprmcccz2hfx0auhd8wsj5knl1 0 70 4503 3690 2019-06-24T23:03:54Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == La clase '''String''' le permite usar y manipular cadenas de texto en formas más complejas que [[string|matriz de caracteres]]. Se requiere más memoria para '''String''' que para una simple matriz de caracteres, pero es mucho mas útil por la cantidad de métodos disponibles y por la administración de memoria automática involucrada. == Sintaxis == <pre> String objeto = cadena; String objeto = String(valor); String objeto = String(valor, base); String objeto = String(valor, decimales); </pre> == Parametros == ;objeto: nombre de instancia de la clase. ;cadena: cadena asignada entre comillas dobles. ;valor: valor numérico asignado. ;base: base que puede ser DEC, BIN, HEX u OCT. ;decimales: numero de decimales que se usara == Metodos == {| class="wikitable" |+Métodos de la clase String !Método!!Descripción |- |[[objeto.substring()]]||Extrae una subcadena |- |[[objeto.concat()]]||Agrega (adjunta) un dato a la cadena |- |[[objeto.charAt()]]||Retorna el caracter ubicado en determinada posición |- |[[objeto.compareTo()]]||Realiza una comparación lexicográfica (para efectos de ordenar) |- |[[objeto.c_str()]]||Retorna un puntero de [[char]] (a manera de [[string]]) como acceso directo al buffer interno |- |[[objeto.equals()]]||Prueba igualdad entre dos cadenas |- |[[objeto.equalsIgnoreCase()]]||Igual al anterior, salvo que no distingue mayúsculas |- |[[objeto.length()]]||Retorna la longitud de cadena (en cantidad de caracteres) |- |[[objeto.trim()]]||Elimina los espacios sobrantes a ambos lados de la cadena |- |[[objeto.toLowerCase()]]||Pasa a minúsculas |- |[[objeto.toUpperCase()]]||Pasa a mayúsculas |- |[[objeto.toCharArray()]]||Copia la cadena de un lugar a otro |- |[[objeto.getBytes()]]||Versión [[byte]] del anterior |- |[[objeto.replace()]]||Reemplaza una o varias porciones de la cadena. |- |[[objeto.remove()]]||Remueve una porción de la cadena |- |[[objeto.indexOf()]]||Retorna el índice de la primera coincidencia con un caracter u otra cadena |- |[[objeto.lastIndexOf()]]||Retorna el índice de la última coincidencia con un caracter u otra cadena |- |[[objeto.startsWith()]]||Verifica si inicia con determinada secuencia (prefijo) |- |[[objeto.endsWith()]]||Verifica si termina con determinada secuencia (sufijo) |- |[[objeto.setCharAt()]]||Cambia un caracter en la cadena |- |[[objeto.toInt()]]||Convierte la cadena en un entero [[long]] |- |[[objeto.toFloat()]]||Convierte la cadena en un punto flotante [[float]] |- |[[objeto.reserve()]]||Modifica el tamaño del buffer interno |} == Comentarios == * La clase '''String''' forma parte del núcleo del [[IDE]] a partir de la versión 0019 y es necesario la instancia de la clase, osea crear un objetos, pero las ventajas son: muchos métodos disponibles y administración automática de memoria. * Las clases String pueden contener caracteres "\0" incrustados, son más rápidas que las [[string|matrices de caracteres]] asignadas en el montón para textos breves y te protegen de los desbordamientos del búfer. == Advertencias == * Tenga en cuenta, que las matrices de caracteres se conocen como [[string]] con s minúscula y las instancias de la '''clase String''' es con S mayúscula. * Las constantes de cadena especificadas con "comillas dobles" son tratadas como [[string|matrices de caracteres]] y no como la '''clase String'''. * [[objeto.c_str()]] debe usarse solamente para lectura, y su puntero dejar de usarse cuando el objeto '''String''' asociado sea destruido. De lo contrario ocurriría, respectivamente, corrupción en el objeto en sí o corrupción en la memoria. * [[objeto.reserve()]] afecta el tamaño del "contenedor", pero no necesariamente lo que retornará [[objeto.length()]] justo después; ya que este último cuenta la longitud real de la cadena y no la de su "contenedor" o "buffer". * [[objeto.compareTo()]] es sensible a las mayúsculas; para sobrellevar este problema, ambas cadenas tendrían que pasar por [[objeto.toLowerCase()]] o [[objeto.toUpperCase()]] de antemano. == Ejemplo 1 == <syntaxhighlight lang="c++"> String x = String(13); //"13" String x = String(13, DEC); //"13" String x = String(13, BIN); //"1101" String x = String(13, HEX); //"D" String pi = String(31416, 4); //"3.1416" </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> String cadena = "Apuntes de Arduino"; cadena.substring(8,10); //de cadena.chatAt(1); //p cadena.length(); //18 cadena.toLowerCase(); //"apuntes de arduino" cadena.toUpperCase(); //"APUNTES DE ARDUINO" </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/variables/data-types/stringobject/ Guia de referencia de Arduino] * [https://www.arduino.cc/reference/es/language/variables/data-types/string/functions/compareto/ Comparador] * [https://www.arduino.cc/reference/es/language/variables/data-types/string/functions/concat/ Concatenar] * [http://arduino.cc/en/Reference/StringGetBytes Copiar a un buffer] * [http://arduino.cc/en/Reference/StringIndexOf Localiza un caracter o string] * [http://arduino.cc/en/Reference/StringLength Longitud del String] * [http://arduino.cc/en/Reference/StringStartsWith Comprueba si comienza por una cadena que se pasa como parámetro] * [http://arduino.cc/en/Reference/StringToCharArray Pasa de String a string] * [https://www.arduino.cc/reference/es/language/variables/data-types/string/functions/charat/ Accede a un caracter concreto del String] * [http://arduino.cc/en/Reference/StringReserve Permite asignar un buffer en memoria para manipular strings] * [https://www.luisllamas.es/convertir-texto-a-numero-arduino/ Convertir texto a numero] - Luis Llamas * [http://panamahitek.com/tipos-de-datos-en-arduino-la-clase-string/ Tipo de datos: La clase String] - José Villalaz [[Category:String]] [[Category:Tipo dato]] 8ngdwczxag4uedd78tb6qo5vktedzxw 0 408 4502 3667 2019-06-24T23:02:04Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Construye una instancia de la clase [[String]]. Existen varias maderas de construir cadenas a partir de diferentes tipos de datos: * Un solo carácter, en comillas simples tipo [[char]]. * Una cadena de caracteres, entre comillas dobles (es decir, una matriz [[char]]) * Otra instancia del objeto [[String]] * Un entero constante o un [[long]] * Un entero constante o [[long]], usando una base especificada [[DEC / BIN / HEX / OCT]]. * Una variable [[int]] o [[long]] * Una variable [[int]] o [[long]], usando una base especificada [[DEC / BIN / HEX / OCT]]. * Un [[float]] o [[double]], usando un valor decimal especificado. La construcción de una cadena a partir de un número da como resultado una cadena que contiene la representación [[ASCII table|ASCII]] de ese número. El valor predeterminado es base diez, por lo que te da CR (\r). == Sintaxis == <pre> String(valor); String(valor, base); String(valor, decimales); </pre> == Parámetros == ;valor:una variable para formatear como [[String]], [[string]], [[char]], [[byte]], [[int]], [[unsigned int]], [[long]], [[unsigned long]], [[float]] o [[double]]. ;base:la base en la que se formatea un valor integral (opcional) ;decimales:los decimales deseados si va es [[float]] o [[double]] == Retorno == una instancia de la clase [[String]] == Advertencias == == Ejemplo == Todas estas declaraciones son verdaderas. <syntaxhighlight lang="c++"> String cadena = String('a'); //Convertir char en objeto String String cadena = "Hola Mundo"; //Usando una cadena String cadena = String("Esta es una cadena"); //Convertir string en objeto String. String cadena = String(cadena + " otra cadena"); //Concatenando dos cadenas String cadena = String(13); //Constante String cadena = String(analogRead(0), DEC); //Usando un int en base decimal String cadena = String(45, HEX); //Usando int en base hexadecimal String cadena = String(255, BIN); //Usando int en base binaria String cadena = String(millis(), DEC); //usando unsigned long en base decimal String cadena = String(5.698, 3); //Usando float con decimales </syntaxhighlight> == Vea también == * [[string]] * [[String]] == Referencias == * [https://www.arduino.cc/en/Reference.StringConstructor Constructor String] [[Category:String]] naero8tp5cvm8d17lx72nd8flkishjb 0 267 3733 1045 2019-05-06T22:07:09Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 260 3725 1038 2019-05-06T22:03:30Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 261 3726 1039 2019-05-06T22:03:54Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 262 3727 1040 2019-05-06T22:04:23Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 263 3728 1041 2019-05-06T22:04:47Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 264 3729 1042 2019-05-06T22:05:10Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 258 3730 1036 2019-05-06T22:06:02Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 265 3731 1043 2019-05-06T22:06:24Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 266 3732 1044 2019-05-06T22:06:47Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 268 3734 1046 2019-05-06T22:07:28Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 269 3735 1047 2019-05-06T22:07:48Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 270 3736 1048 2019-05-06T22:08:11Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Caracteres</categorytree> == Referencias == [[Category:Caracteres]] eehsp8z2mxqpvgpfn3yplnugvdwkce3 0 246 3756 1017 2019-05-06T22:17:28Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Estructuras de control</categorytree> == Referencias == [[Category:Estructuras de control]] owhftcjoep9mx6gdloryrwklf4owjuv 0 247 3757 1018 2019-05-06T22:17:52Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Estructuras de control</categorytree> == Referencias == [[Category:Estructuras de control]] owhftcjoep9mx6gdloryrwklf4owjuv 0 379 3777 3776 2019-05-06T22:35:26Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == '''American Standard Code for Information Interchange''' ASCII, es la representación numérica de los caracteres estandar. Las computadoras sólo pueden entender números, por lo que el código ASCII se desarrolló para solucionar este problema. == 32 primeros == Los primeros 32 caracteres son de control, no imprimibles. {|class="wikitable" !DEC!!Carácter!!Descripción!!DEC!!Carácter!!Descripción |- |0||NULL||Carácter nulo||16||DLE||Esc. vínculo datos |- |1||SOH||inicio encabezado||17||DC1||control disp. 1 |- |2||STX||inicio texto||18||DC2||control disp. 2 |- |3||ETX||fin de texto||19||DC3||control disp. 3 |- |4||EOT||fin transmisión||20||DC4||control disp. 4 |- |5||ENQ||consulta||21||NAK||conf. negativa |- |6||ACK||reconocimiento||22||SYN||inactividad sínc |- |7||BEL||timbre||23||ETB||fin bloque trans |- |8||BS||retroceso||24||CAN||cancelar |- |9||HT||tab horizontal||25||EM||fin del medio |- |10||LF||nueva línea||26||SUB||sustitución |- |11||VT||tab vertical||27||ESC||escape |- |12||FF||nueva página||28||FS||sep. archivos |- |13||CR||retorno de carro||29||GS||sep. grupos |- |14||SO||desplaza afuera||30||RS||sep. registros |- |15||SI||desplaza adentro||31||US||sep. unidades |- | || || ||127||DEL||Suprimir |} == Imprimibles == Los caracteres imprimibles. {|class="wikitable col1cen col2cen col3cen col4cen" !Codigo!!Caracter!!Codigo!!Caracter |- |32||espacio||48||0 |- |33||!||49||1 |- |34||"||50||2 |- |35||#||51||3 |- |36||$||52||4 |- |37||%||53||5 |- |38||&||54||6 |- |39||'||55||7 |- |40||(||56||8 |- |41||)||57||9 |- |42||*||58||: |- |43||+||59||; |- |44||,||60||< |- |45||-||61||= |- |46||.||62||> |- |47||/||63||? |} {|class="wikitable col1cen col2cen col3cen col4cen" !Codigo!!Caracter!!Codigo!!Caracter |- |64||@||96||` |- |65||A||97||a |- |66||B||98||b |- |67||C||99||c |- |68||D||100||d |- |69||E||101||e |- |70||F||102||f |- |71||G||103||g |- |72||H||104||h |- |73||I||105||i |- |74||J||106||j |- |75||K||107||k |- |76||L||108||l |- |77||M||109||m |- |78||N||110||n |- |79||O||111||o |- |80||P||112||p |- |81||Q||113||q |- |82||R||114||r |- |83||S||115||s |- |84||T||116||t |- |85||U||117||u |- |86||V||118||v |- |87||W||119||w |- |88||X||120||x |- |89||Y||121||y |- |90||Z||122||z |- |91||[||123||{ |- |92||\||124||<nowiki>|</nowiki> |- |93||]||125||} |- |94||^||126||~ |- |95||_|| || |} == Caracteres especiales == == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == * [https://manueldelgadocrespo.blogspot.com/p/ta.html Tabla ASCII] - Manuel Delgado * [https://elcodigoascii.com.ar/ Codigo ASCII] [[Category:Serial]] en6b4qkc2vhibd3mgnm41sw83becc08 0 414 4762 4759 2019-07-15T22:21:48Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == La librería [https://github.com/PaulStoffregen/Time TimeLib.h] de Paul Stoffregen... == Placas aplicables == Todas. == time_t == [[time_t]] es un tipo [[unsigned long]] de 4 byte (32 bits) usado para almacenar los segundos transcurridos desde el 1-ENE-1970 o también llamada [https://www.unixtimestamp.com Unix Time Stamp]. === Sintaxis === <pre> time_t variable [= valor]; </pre> === Parámetros === ;variable: Nombre de la variable que definiras. ;valor: Numero del tipo TimeStamp de UNIX. Numero tipo [[unsigned long]]. === Funciones === {|class="wikitable" |+Funciones disponibles para time_t |- !Función!!Descripción!!Ejemplo |- |[[now()]]||Almacena la hora actual en tiempo UNIX||time_t t = now(); |- |year()||Muestra el año||year(); |- |month()||Muestra el mes (1~12)||month(); |- |monthStr()||Nombre del mes (January, February, March, April, May, June, July...)||monthStr(month()); |- |monthShortStr()||Nombre corto del mes (Jan, Feb, Mar, Dic) ||monthShortStr(month()); |- |day()||Muetsra el dia (1~31)||day(); |- |weekday()||Muestra dia de la semana (1=domingo) (1~7)||weekday(); |- |dayStr()||Nombre del dia (Sunday, Monday, Tuesday, Wenesday, Thursday, Friday, Saturday)||dayStr(weekday()); |- |dayShortStr()||Nombre corto del dia (Sun, Mon, Tue, Wen, Thu, Fri, Sat)||dayShortStr(weekday()); |- |hour()||Muestra las horas (0~23)||hour(); |- |minute()||Muestra los minutos (0~59)||minute(); |- |second()||Muestra los segundos (0~59)||second(); |- |[[millis()]]||Muestra los milisegundos (0~999)||millis(); |- |hourFormat12()||Formatea a 12 horas|| |- |isAM()||Devuelve verdadero por la mañana||isAM() |- |isPM()||Devuelve verdadero por la tarde||isPM(); |- |[[setTime()]]||Establece fecha-hora. Puede ser en segundos o hr,min,sec,dia,mes,año.||setTime(0,0,0,14,7,2018); |- |[[adjustTime()]]||Ajusta la fecha-hora del sistema agregando un valor||adjustTime(3600); |- |[[setSyncProvider()]]||Establecer proveedor de hora externa|| |- |[[setSyncInterval()]]||Establecer el número de segundos entre re-sincronizaciones|| |- |[[makeTime()]]||Convierte variable tipo '''tmElement_t''' en variable tipo '''time_t'''||makeTime(tm); |- |[[breakTime()]]||Convierte variable tipo '''time_t''' en variable tipo '''tmElement_t'''||makeTime(tm); |- |[[timeStatus()]]||Indica si el tiempo se sincronizado recientemente. Devuelve: timeNotSet/timeNeedSync/timeSet|| |} == tmElements_t == [[tmElements_t]] es una matriz de seis (6) elementos que proporciona la libreria '''TimeLib.h''' y que permite manipular de manera fácil (sin tener que usar el Tiempo Unix) todos los elementos necesarios para definir una fecha-hora. === Sintaxis === <pre> tmElements_t variable; </pre> === Parámetros === ;variable:Nombre de la variable que definiras. === Métodos === {| class="wikitable" |+Metodos disponibles para tmElementos_t |- ! Metodo !! Descripcion |- | .Second || Segundo (0~59) |- | .Minute || Minuto (0~59) |- | .Hour || Hora (0~23) |- | .Day || Dia (1~31) |- | .Month || Mes (1~12) |- | .Year || Año (0~99) resta de 1970. |- |[[makeTime()]]||Convierte variable tipo [[tmElements_t]] en variable tipo [[time_t]]. |- |[[breakTime()]]||Convierte variable tipo [[time_t]] en variable tipo [[tmElements_t]]. |} {{Nota|Para representar el año 2019 debes poner 49 (2019-1970) y no olvidar sumar 1920 nuevamente al resultado.}} == Comentarios == == Advertencias == == Ejemplo 1 == En este ejemplo incluimos la fecha hora 2018-7-14 10:0:0 y mostramos su avance cada 1350 milisegundos. <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(9600); setTime(10,0,0,14,7,2018); //h,min,seg,dia,mes,año } void loop(){ time_t t=now(); Serial.print(hour(t)); Serial.print(":"); Serial.print(minute(t)); Serial.print(":"); Serial.println(second(t)); delay(1350); } </syntaxhighlight> == Ejemplo 2 == En este ejemplo podemos enviar la fecha-hora por consola serie. Para convertir Unix Time te recomiendo usar esto. Ejemplo: T1552204800 = 2019-MAR-10 8:00:00 <syntaxhighlight lang="c++"> #include <TimeLib.h> #define TIME_HEADER "T" //Encabezado de mensaje de sincronizacion void setup() { Serial.begin(9600); while (!Serial); //Solo se requiere para Leonardo pinMode(13, OUTPUT); Serial.println("Esperando mensaje de sincronizacion"); } void loop(){ if (Serial.available()) { sincro(); } if (timeStatus() == timeSet) { pantalla(); //Muestra fecha hora digitalWrite(13, HIGH); //Sincronizado }else{ digitalWrite(13, LOW); //Requiere sincronizar } delay(1000); } void sincro() { if (Serial.find(TIME_HEADER)) { unsigned long pctime = Serial.parseInt(); if (pctime >= 1357041600) { //Verifica valides de fecha-hora (mayor a 1-ENE-2013) setTime(pctime); //Sincroniza reloj Arduino con fecha-hora recivida por puerto serie } } } void pantalla(){ Serial.print(year()); Serial.print('-'); Serial.print(month()); Serial.print('-'); Serial.print(day()); Serial.print(' '); Serial.print(hour()); printDigito(minute()); printDigito(second()); Serial.println(); } void printDigito(int dig){ Serial.print(':'); if (dig < 10){ Serial.print('0'); } Serial.print(dig); } </syntaxhighlight> == Ejemplo 3 == Con este ejemplo Arduino espera que se envíe desde el monitor un tiempo UNIX del formato T1531526400 (2018-7-14 0:0:0). <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(9600); pinMode(13, OUTPUT); Serial.println("Esperando tiempo UNIX por puerto serie"); } void loop(){ if (Serial.available()) { sincroniza(); } if (timeStatus()!= timeNotSet) { reloj(); } if (timeStatus() == timeSet) { digitalWrite(13, HIGH); //Sincronizado }else{ digitalWrite(13, LOW); //Falta sincronizar } delay(1000); } void reloj(){ Serial.print(year()); Serial.print("-"); if (month()<10){ Serial.print('0'); } Serial.print(month()); Serial.print("-"); if (day()<10){ Serial.print('0'); } Serial.print(day()); Serial.print(" "); if (hour()<10){ Serial.print('0'); } Serial.print(hour()); Serial.print(":"); if (minute() < 10){ Serial.print('0'); } Serial.print(minute()); Serial.print(":"); if (second() < 10){ Serial.print('0'); } Serial.println(second()); } void sincroniza() { const unsigned long DEFAULT_TIME = 1514764800; //1-ENE-2018 if (Serial.find("T")) { unsigned long pc = Serial.parseInt(); //Controla valides mayor a 1-ENE-2018 if (pc >= DEFAULT_TIME) { setTime(pc); //Ajusta la fecha-hora } } } </syntaxhighlight> == Ejemplo 4 == Mostramos las cadenas de dia y mes. Recuerde que no es opcional el parametro. <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(9600); for (byte n=1; n<=7; n++){ Serial.print(dayStr(n)); Serial.print(" - "); Serial.println(dayShortStr(n)); } Serial.println("-------"); for (byte n=1; n<=12; n++){ Serial.print(monthStr(n)); Serial.print(" - "); Serial.println(monthShortStr(n)); } } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] * [http://playground.arduino.cc/code/time Time] de Paul Stoffregen * [https://github.com/PaulStoffregen/TimeAlarms TimeAlarms] de Paul Stoffregen * [https://github.com/PaulStoffregen/TimerOne TimerOne] de Paul Stoffregen * [http://www.arduino.cc/playground/Code/TimedAction TimedAction] de Alexander Brevig [[Category:Librerias]] [[Category:Libreria Time]] cs6fgi3t3hlnwb32poriq75obqkjzi1 0 481 4763 4761 2019-07-15T22:22:48Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == [https://github.com/PaulStoffregen/TimeAlarms TimeAlarm] es una libreria de Paul Stoffregen y es un complemento de la libreria Time para realizar tareas a intervalos especificos. {{Tip|Los intervalos a programar pueden ir desde 1 segundo hasta años. Para intervalor mas cortos vea la libreria [http://www.arduino.cc/playground/Code/TimedAction TimedAction] de Alexander Brevig.}} == Tipos de tareas == Existen dos tipos de tareas que se pueden crear para que se repitan continuamente o para que se realicen una sola vez. ;Alarmas:Las tareas programadas a una hora particular del día. ;Temporizadores:Las tareas programadas una vez transcurrido un intervalo de tiempo. == Sintaxis == <pre> #include <Time.h> #include <TimeAlarms.h> setTime(hh,mm,ss,d,m,a); Alarm.alarmRepeat([dia,]hh,mm,ss, funcion1); Alarm.alarmRepeat(valor, funcion2); Alarm.alarmOnce([dia,]hh,mm,ss, funcion3); Alarm.alarmOnce(valor, funcion4); Alarm.timerRepeat(hh,mm,ss, funcion5); Alarm.timerRepeat(valor, funcion6); Alarm.timerOnce(hh,mm,ss, funcion7); Alarm.timerOnce(valor, funcion8); Alarma.triggerOnce(valor, funcion9); Alarm.delay(ms); </pre> == Parámetros == ;dia:Dia de la semana. dowMonday, dowSaturday. ;hh:Hora ;mm:Minutos ;ss:Segundos ;ms:Milisegundos ;valor:Valor de tiempo tipo [[time_t]] ;Funcion:Nombre de la función que se invoca al cumplirse el tiempo == Retorno == Lo que hace cada una de estos métodos es activar la función asociada. == Métodos == {| class="wikitable" |+Metodos de libreria TimeAlarm |- ! Método !! Descripción |- | Alarm.alarmRepeat([dia,]hh,mm,ss, AlarmFunction); || Alarma continua todos los dias |- | Alarm.alarmOnce([dia,]hh,mm,ss, AlarmFunction); || Alarma que se activa la proxima ves que ocurra. |- | Alarm.triggerOnce(value, AlarmFunction); || Una sola alarma determinada por valor [[time_t]] |- | Alarm.timerRepeat(hh,mm,ss, TimerFunction); || Llama continuamente a TimerFunction |- | Alarm.timerOnce(hh,mm,ss, TimerFunction); || Llama una sola vez a TimerFunction |- | Alarm.delay(periodo) || Similar de [[delay()]] de Arduino, periodo dedo en milisegundos. |} == Funciones de bajo nivel == {| class="wikitable" |+Metodos de libreria TimeAlarm |- ! Método !! Descripción |- | disable(ID); || evitar que la alarma asociada con la ID dada se dispare. |- | enable(ID); || habilita la alarma con el ID dado. |- | write(ID, valor); || Sobreescribe la alarma ID con el valor |- | read(ID); || Lee la alarma ID |- | readType(ID); || Retorna el tipo de alarma |- | getTriggeredAlarmId(); || Retorna el ID de la alarma activa. |} == Comentarios == * Esta libreria requiere de la liberia [[Time]] * Los intervalos a programar pueden ir desde 1 segundo hasta años. == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> #include <Time.h> #include <TimeAlarms.h> void setup(){ Serial.begin(9600); setTime(8,29,0,1,7,19); //Poner tiempo a las 8:29:00 am del -JUL-2019 Alarm.alarmRepeat(8,30,0, MorningAlarm); //Todos los dias a las 8:30 Alarm.alarmRepeat(17,45,0, EveningAlarm); //Todos los dias a las 5:45pm Alarm.alarmRepeat(dowSaturday,8,30,30, WeeklyAlarm); //Cada sabado a las 8:30:30am Alarm.timerRepeat(15, Repeats); //Cada 15 segundos Alarm.timerOnce(10, OnceOnly); //Dentro de 10 segundos } void loop(){ relog(); Alarm.delay(1000); //Espera 1 segundo } // functions to be called when an alarm triggers: void MorningAlarm(){ Serial.println("Alarma: apaga luces"); } void EveningAlarm(){ Serial.println("Alarma: prende luces"); } void WeeklyAlarm(){ Serial.println("Alarma: Es lunes temprano"); } void ExplicitAlarm(){ Serial.println("Alarma: - this triggers only at the given date and time"); } void Repeats(){ Serial.println("Temporizador: cada 15 segundos."); } void OnceOnly(){ Serial.println("Temporizador: solo una vez."); } void relog(){ if (hour() < 10){ Serial.print('0'); } Serial.print(hour()); Serial.print(':'); if (minute() < 10){ Serial.print('0'); } Serial.print(minute()); Serial.print(':'); if (second() < 10){ Serial.print('0'); } printDigits(); Serial.println(second()); } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] * [http://playground.arduino.cc/code/time Time] de Paul Stoffregen * [https://github.com/PaulStoffregen/TimeAlarms TimeAlarms] de Paul Stoffregen * [https://github.com/PaulStoffregen/TimerOne TimerOne] de Paul Stoffregen * [http://www.arduino.cc/playground/Code/TimedAction TimedAction] de Alexander Brevig [[Category:Librerias]] [[Category:Libreria Time]] g21dwq9ahnk9n650w34zpekulafchxn 0 397 5138 5137 2020-01-23T16:43:53Z Kike GL 2 /* Ejemplo 1 */ wikitext text/x-wiki == Descripción == Funcion util para representar un intervalo de tiempo con precision de segundos. == Sintaxis == <pre> #include <RTClib.h> TimeSpan(dd,hh,mm,ss); TimeSpan(segundos); </pre> == Parámetros == ;dd:dias tipo [[int]] (0 a 365) ;hh:horas tipo [[byte]] (0 a 23) ;mm:minutos tipo [[byte]] (0 a 59) ;ss:segundos tipo [[byte]] (0 a 59) ;segudos:numero de segundos totales (int) (0 a 32...) == Retorna == == Métodos == {| class="wikitable" |- ! Metodo !! Descripción |- | .days() || Dias |- | .hours() || Horas |- | .minutes() || Minutos |- | .seconds() || Segundos |- | .totalsecons() || Segundos totales |} == Comentarios == == Advertencias == * Tenga en cuenta que el método .day() se usa con [[DateTime]] mientras que aquí en método es '''days()'''. * Debe trabajar con el tipo de dato [[DateTime]] == Ejemplo 1 == <syntaxhighlight lang="c++"> #include <RTClib.h> DateTime t1 (2018,7,14,8,0,0); //2018-7-14 8:00:00 DateTime t2 (2018,7,14,18,0,0); //2018-7-14 18:00:00 //Calculos 1 TimeSpan t3 = t2 - t1; //Mostrar Serial.print(t3.days()); //0 Serial.print(t3.hours()); //10 Serial.print(t3.minutes()); //0 Serial.print(t3.seconds()); //0 //Calculos 2 DateTime t4 = t1 + TimeSpan(0,1,0,0); //Añadir una hora DateTime t5 = t1 + TimeSpan(1,0,0,0); //Añadir un dia DateTime t6 = t1 - TimeSpan(7,0,0,0); //Restar una semana //Mostrar Serial.print(t4.day()); //14 Serial.print(t4.hour()); //9 Serial.print(t4.minute()); //0 Serial.print(t4.second()); //0 </syntaxhighlight> {{Nota|No confundas el metodo day() de DateTime con el metodo .days() de TimeSpan.}} == Vea también == <categorytree mode=all>Libreria RTC</categorytree> <categorytree mode=all>Libreria Time</categorytree> == Referencias == * [https://adafruit.github.io/RTClib/html/class_time_span.html Clase TimeSpan()] - Adafruit * [https://github.com/adafruit/RTClib RTClib] - Adafruit * [https://learn.adafruit.com/ds1307-real-time-clock-breakout-board-kit/what-is-an-rtc Que es RTC] - Adafruit [[Category:Libreria RTC]] bwri4l4wb842z15gql8skgnc0vjigyi 0 372 4869 2049 2019-09-13T21:30:09Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Hay varias maneras de detener la ejecución de un [[boceto]] Arduino, también depende de lo que espere que sea "detenido". Digo esto porque el Arduino no usa un sistema operativo, su [[boceto]] nunca puede salir a ninguna parte, ya que es todo lo que el AVR tiene que trabajar. A continuacion algunas alternativas para detener el dispositivo. == Sin loop() == Cuando solo se quiere efectuar un calculo por ejemplo y no es necesario tener la repetitividad, deja en blanco [[loop()]] <pre> void setup(){ Serial.begin(115200); Serial.println(sq(3)); } void loop(){ //Nada } </pre> == Manualmente == Cuando se usa el método Arduino normal para escribir un [[boceto]] con [[setup()]] y [[loop()]], su programa se ejecutará para siempre, lo que significa que la única vez que se puede detener a Arduino es cuando se elimina la energía. Para poner el Arduino en un estado parado, podemos simplemente usar un bucle infinito para bloquear efectivamente la uC, bueno, casi... <pre> while (true){} </pre> Este no es exactamente el resultado que estamos buscando todavía, ya que el Arduino usa un mecanismo llamado [[interrupciones]] para proporcionar una gran cantidad de funcionalidad y detienen el flujo del programa principal para que se ejecute "algo". Entonces, para completar este código para "detener" el uC, podemos agregar la función AVR para deshabilitar las interrupciones globales (o todas). <pre> noInterrups(); while (true){} </pre> == Funciones de C == También podemos usar la funcion C '''cli()''' o '''abort()''' o '''exit()'''. Entonces hay tres métodos para detener el Arduino, y cada uno hace lo mismo, sin embargo, cada uno se compila a un tamaño diferente en las pruebas. Con cualquiera de estos métodos el [[boceto]] sigue dando vueltas a toda velocidad y está completamente bloqueado hasta que se apaga la corriente, ya sea físicamente o mediante el uso del botón de reinicio. == Poner a dormir == Con la administración avanzada de la energía se puede usar para poner el dispositivo en modo de suspensión y usar menos energía. Sin embargo, si el dispositivo es recuperable sin un reinicio, el dispositivo se vuelve mucho más amigable para el usuario. La documentación de AVR para "Administración de energía y modos de suspensión" tiene algunos ejemplos de cómo dormir el uC. Sleeping se puede usar tanto para una pausa controlada como para un bloqueo completo, similar al ciclo infinito explicado anteriormente. <pre> cli(); sleep_enable(); sleep_cpu(); sleep_mode(); sleep_bod_disable() </pre> La funcion sleep_disable() no es necesaria ya que el dispositivo nunca se despertará debido a que las interrupciones se desactivan. == Vea también == <categorytree mode=all>Tips</categorytree> == Referencias == * [http://arduino.land/FAQ/content/7/47/en/how-to-stop-an-arduino-sketch.html Arduino Land] * [http://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html Standard C library for AVR-GCC] [[Category:Tips]] knj9hbbs2xheiicjtr3u2esnume8h23 0 483 4829 2019-07-24T23:37:04Z Kike GL 2 Página creada con «== Descripción == Si tenemos dispositivos en casa como camaras IP, automatismos gobernados por Internet, NAS que contienen datos, etc; acceder a ellos es fácil si tenemos...» wikitext text/x-wiki == Descripción == Si tenemos dispositivos en casa como camaras IP, automatismos gobernados por Internet, NAS que contienen datos, etc; acceder a ellos es fácil si tenemos una IP fija. Si no disponemos de ella por precio o disponibilidad, hay otros métodos que no son fáciles de configurar o también son de pago. Esta solución nos envia un correo electrónico cada vez que cambia nuestra IP y así poder acceder a casa sin problemas. Solo necesitamos un ESP8266 y una cuenta de Gmail. La libreria Gsender nos facilita mucho la programación y además podemos usar la misma cuenta de Gmail para enviar y recibir ese correo. El programa conecta con nuestro router y usa un servicio gratuito ipify.org que nos devuelve nuestra IP. Si es diferente a la que ya teniamos antes, entonces nos manda un correo a nuestro teléfono con la nueva. Solo tenemos que determinar con que frecuencia queremos que el programa haga esa verificación == Código == <syntaxhighlight lang="c++"> #include "ESP8266WiFi.h" #include "Gsender.h" const char* ssid = "Jopapa"; const char* password = "pepitogrillo"; String miIP="0.0.0.0"; //Para que en primera conexión nos diga la que tenemos void setup() { Serial.begin(115200); delay(10); //Conexión a nuestro router Serial.println(); Serial.print("Conectando a "); Serial.println(ssid); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED){ delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi conectada"); Serial.print("Direccion IP interna del ESP8266: "); Serial.println(WiFi.localIP()); } void loop() { String ip = getIp(); if (ip != miIP){ Serial.println("Atencion, tu IP ha cambiado"); Serial.println("Tu anterior IP era: "+ miIP); miIP=ip; Serial.println("Tu actual IP es: " + miIP); //Enviar e-mail con la nueva IP Gsender *gsender = Gsender::Instance(); String subject = "Tu nueva IP"; if (gsender->Subject(subject)->Send("jopapagrillo@gmail.com", "Tu actual IP es: " + miIP)) { Serial.println("Mensage enviado."); }else{ Serial.print("Error enviando mensage: "); Serial.println(gsender->getError()); } } //Crear aquí un delay o un millis para chekear la IP, por ejemplo cada hora o más delay(60000); } String getIp(){ WiFiClient client; if (client.connect("api.ipify.org", 80)) { Serial.println("Conectado a ipify.org"); client.println("GET / HTTP/1.0"); client.println("Host: api.ipify.org"); client.println(); }else{ Serial.println("Conexión a ipify.org fallida"); return String(); } delay(5000); String line; while(client.available()){ line = client.readStringUntil('\n'); //Serial.println(line); } return line; } </syntaxhighlight> == Vea también == <categorytree mode=all>Tips</categorytree> == Referencias externas == * [http://www.jopapa.me/ippormail.html Saber nuestra IP por Mail] - jojopapa [[Category:Tips]] 5izrxc68ebbusytlda7sncutr42z5mm 0 486 4967 4966 2019-09-25T16:40:00Z Kike GL 2 /* Código 4 */ wikitext text/x-wiki == Descripción == Intentare explicar la diferencia entre usar [[delay()]] y [[millis()]]. Ambos códigos hacen lo mismo prender y apagar un LED cada 0.5 seg. {{Tip|Este metodo permite a Arduino hacer mas cosas en el mismo ciclo.}} == Código 1 == Este ejemplo funciona muy bien porque lo único que tiene que hacer Arduino es prender y apagar el LED. Pero si ademas quisieras hacer algo mas no funcionaria porque los [[delay()]] paralizan todas las operaciones y no habria tiempo para hacer nada mas. Aumentar el valor de n por ejemplo. <syntaxhighlight lang="c++"> unsigned long n; void setup(){ Serial.begin(9600); pinMode(13, OUTPUT); } void loop(){ digitalWrite(13, HIGH); //Prende LED delay(500); //Espera 0.5 seg digitalWrite(13, LOW); //Apaga LED delay(500); //Espera 0.5 seg n++; Serial.println(n); } </syntaxhighlight> {{Nota|Veras que el valor de n se incrementa cada 1 segundo.}} == Código 2 == Con este codigo te das cuenta que Arduino puede hacer otras tareas (aumentar el valor de n por ejemplo), porque le sobra tiempo hasta que debe conmutar el LED, porque el corre a una velocidad muy superior. Aproximadamente a 16 MHz. <syntaxhighlight lang="c++"> unsigned long n,t; void setup(){ Serial.begin(9600); pinMode(13, OUTPUT); } void loop(){ if (millis() - t > 500){ digitalWrite(13, !digitalRead(13)); //Conmuta LED t = millis(); } n++; Serial.println(n); } </syntaxhighlight> {{Nota|Veras que el valor de n se incrementa muy rápidamente en cada ciclo de loop().}} == Código 3 == Con este código te das cuenta que Arduino puede aparentar multihilo haciendo que dos LED intermitentes a destiempo. <syntaxhighlight lang="c++"> const byte pinRojo = 4; //LED rojo const byte pinVerde = 5; //LED verde bool estadoRojo; //Estado LED rojo unsigned long previoRojo; //Ultimo cambio LED rojo int intervaloRojo = 500; //Intervalo LED rojo (milliseconds) bool estadoVerde; //Estado LED verde unsigned long previoVerde; //Ultimo cambio LED verde int intervaloVerde = 1000; //Intervalo LED verde (milliseconds) void setup() { pinMode(pinRojo, OUTPUT); pinMode(pinVerde, OUTPUT); } void loop(){ LedRojo(); LedVerde(); } void LedRojo(){ if (millis() - previoRojo > intervaloRojo) { previoRojo = millis(); estadoRojo = !estadoRojo; digitalWrite(pinRojo, estadoRojo); } } void LedVerde(){ if (millis() - previoVerde > intervaloVerde) { previoVerde = millis(); estadoVerde = !estadoVerde; digitalWrite(pinVerde, estadoVerde); } } </syntaxhighlight> {{Nota|Veras que cada LED puede ir a su propio ritmo de forma independiente.}} == Código 4 == Se me ocurrio comparar la velocidad de algunas instrucciones. <syntaxhighlight lang="c++"> bool x; int n; void setup(){ Serial.begin(115200); pinMode(13, OUTPUT); } void loop(){ //digitalWrite(13, !digitalRead(13)); //598 124 digitalWrite(13, x); //787 629 x = !x; //PORTB = PORTB ^ 32; //1446 372 n++; if (millis() > 5000){ Serial.println(n); while (1); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Tips</categorytree> == Referencias externas == * [http://www.jopapa.me/ippormail.html Saber nuestra IP por Mail] - jojopapa [[Category:Tips]] qebiofz3zsps0iwygyu5idqb1o0blzj 0 489 5113 4916 2019-12-16T23:22:58Z Kike GL 2 /* Código 2 */ wikitext text/x-wiki == Descripción == Como detectar el flanco de subida (RISSING) de un pulsador, rele o dispositivo con contacto mecánico. {{Tip|Este método soluciona el efecto de rebote.}} == Código 1 == Con este código detectamos el flanco de subida (RISSING) de un contacto mecánico con una conexión en pulldown. <syntaxhighlight lang="c++"> bool actual,anterior; void setup(){ Serial.begin(9600); pinMode(2, INPUT); } void loop(){ actual = digitalRead(2); if (actual && !anterior){ Serial.println("Flanco de subida detectado"); } anterior = actual; } </syntaxhighlight> {{Nota|Veras que solo aparece una vez el mensaje de deteccion por cada pulsacion sin importar e tiempo que dure dicha pulsacion.}} == Código 2 == Con este código detectamos el flanco de bajada (FALING) de un contacto mecánico con una conexión en pullup. <syntaxhighlight lang="c++"> bool actual,anterior; void setup(){ Serial.begin(9600); pinMode(2, INPUT_PULLUP); } void loop(){ actual = digitalRead(2); if (!actual && anterior){ Serial.println("Flanco de bajada detectado"); } anterior = actual; } </syntaxhighlight> {{Nota|El unico cambio es en la condicion del if().}} == Código 3 == En este ejemplo tenemos que detectar el numero de pulsaciones de un boton durante medio seg y de acuerdo a eso prender un LED distinto durante 3 seg adicionales. <syntaxhighlight lang="c++"> bool valor,anterior,LED; unsigned long t1; byte n; void setup(){ pinMode(2, OUTPUT); pinMode(3, OUTPUT); pinMode(4, OUTPUT); ... pinMode(12, INPUT_PULLUP); } void loop(){ valor = digitalRead(12); if (!valor && anterior && !LED){ if (n == 0){ t1 = millis(); } n++; } anterior = valor; //Detiene lectura en medio seg if (millis() - t1 > 500 && n > 0 && !LED){ LED = true; } //Acciona LED if (LED){ digitalWrite(n+1, HIGH); } //Apagar todo luego de 3 seg if (millis() - t1 > 3500 && LED){ LED = false; digitalWrite(n+1, LOW); n = 0; } } </syntaxhighlight> == Vea también == <categorytree mode=all>Tips</categorytree> == Referencias externas == [[Category:Tips]] s7jhndpla5us4tcuh8tpy0bhbgptjpj 0 493 4985 4984 2019-09-26T17:00:15Z Kike GL 2 /* Referencia externa */ wikitext text/x-wiki == Descripción == Cuando tenemos que manejar muchos pines, es mejor adecuar nuestros requerimientos a bancos completos y manejar el banco directamente porque es mucho mas rápido en Arduino. == Ejemplo == En este ejemplo queremos poner como salidas los pines D2 a D13, del D2 a D10 en LOW y D11 a D13 en HIGH. {{Tip|No debemos cambiar los pines 0 (Rx) y 1 (Tx) o no funcionara el puerto serie.}} <syntaxhighlight lang="c++"> void setup() { byte pin; for (pin=2; pin<=13; ++pin) { pinMode(pin, OUTPUT); } for (pin=2; pin<=10; ++pin) { digitalWrite(pin, LOW); } for (pin=11; pin<=13; ++pin) { digitalWrite(pin, HIGH); } } </syntaxhighlight> Este código hace lo mismo pero mucho mas rapido. <syntaxhighlight lang="c++"> void setup(){ //Pines D7..D1 (Tx) como salida y D0 (Rx) como entrada DDRD = B11111110; //Pines digitales: 7,6,5,4,3,2,1,0 //Pines D13..D8 como salidas DDRB = B00111111; //Pines digitales: -,-,13,12,11,10,9,8 //Pines D7..D2 en LOW PORTD &= B00000011; //Apaga: 2..7; deja tan cual 0 y 1. //Pines D13..D11 en HIGH y D10..D8 en LOW PORTB = B00111000; //Prende: 13,12,11; apaga: 10,9,8. } </syntaxhighlight> == Vea también == <categorytree mode=all>Tips</categorytree> == Referencia externa == * [https://playground.arduino.cc/Code/BitMath/ Bit Math] - Playgroung Arduino [[Category:Tips]] iejuancujn84vu41d02t85wyorhomnc 0 448 5044 5043 2019-10-07T21:31:02Z Kike GL 2 /* Ejemplo 3 */ wikitext text/x-wiki == Descripción == La librería [https://github.com/bhagman/Tone Tone] de Brett Hagman para producir una onda cuadrada de la frecuencia especificada en el rango audible, con un ciclo de trabajo del 50%, en cualquier pin de Arduino. Opcionalmente, se puede especificar una duración; de lo contrario, la onda continúa hasta que la funcion stop() sea invocada. El pin se puede conectar a un zumbador piezoeléctrico u otro altavoz para reproducir tonos. {{Nota|Desde Arduino IDE 18 esta incorporada una version simplificada.}} == Placas aplicables == La cantidad de tonos que se pueden reproducir simultáneamente depende de la cantidad de temporizadores de hardware (con capacidad CTC) disponibles en el microcontrolador. {| class="wikitable col2cen" |+Arduino segun uC |- ! Ardujno !! Cantidad !! Temporizadores |- | ATmega 8 || 2 || 2 y 1 |- | ATmega 168/328 || 3 || 2, 1 y 0 |- | ATmega 1280 || 6 || 5, 4, 3, 2, 1 y 0 |} {{Nota|El orden de asignacion de temporizadores es el referido}} == Sintaxis == <pre> #include <Tone.h> Tone pito; </pre> == Métodos == {| class="wikitable" |+Métodos disponibles para librería Tone.h |- ! Método !! Descripción |- | begin(pin) || Prepara un pin para tocar un tono. |- | isPlaying() || Devuelve true si el tono se esta reproducionedo. |- | play(frecuencia [, duracion]) || Toca un tono de la frecuencia (Hz), por duracion de milisegundos. Si no pone duracion el tono se tocada indefinidamenre hasta stop(). |- | stop() || Deja de tocar el tono. |} {{Nota|play() no bloque al Arduino independientemente de duracion.}} == Lista de frecuencias == {| class="wikitable" |+Frecuencias posibles |- ! Contante !! Frecuencia (Hz) !! Constante !! Frecuencia (Hz) !! Constante !! Frecuencia (Hz) |- | NOTA_B0 || 31 || NOTA_A3 || 220 || NOTA_G6 || 1568 |- | NOTA_C1 || 33 || NOTA_AS3 || 233 || NOTA_GS6 || 1661 |- | NOTA_CS1 || 35 || NOTA_B3 || 247 || NOTA_A6 || 1760 |- | NOTA_D1 || 37 || NOTA_C4 || 262 || NOTA_AS6 || 1865 |- | NOTA_DS1 || 39 || NOTA_CS4 || 277 || NOTA_B6 || 1976 |- | NOTA_E1 || 41 || NOTA_D4 || 294 || NOTA_C7 || 2093 |- | NOTA_F1 || 44 || NOTA_DS4 || 311 || NOTA_CS7 || 2217 |- | NOTA_FS1 || 46 || NOTA_E4 || 330 || NOTA_D7 || 2349 |- | NOTA_G1 || 49 || NOTA_F4 || 349 || NOTA_DS7 || 2489 |- | NOTA_GS1 || 52 || NOTA_FS4 || 370 || NOTA_E7 || 2637 |- | NOTA_A1 || 55 || NOTA_G4 || 392 || NOTA_F7 || 2794 |- | NOTA_AS1 || 58 || NOTA_GS4 || 415 || NOTA_FS7 || 2960 |- | NOTA_B1 || 62 || NOTA_A4 || 440 || NOTA_G7 || 3136 |- | NOTA_C2 || 65 || NOTA_AS4 || 466 || NOTA_GS7 || 3322 |- | NOTA_CS2 || 69 || NOTA_B4 || 494 || NOTA_A7 || 3520 |- | NOTA_D2 || 73 || NOTA_C5 || 523 || NOTA_AS7 || 3729 |- | NOTA_DS2 || 78 || NOTA_CS5 || 554 || NOTA_B7 || 3951 |- | NOTA_E2 || 82 || NOTA_D5 || 587 || NOTA_C8 || 4186 |- | NOTA_F2 || 87 || NOTA_CS5 || 622 || NOTA_DS8 || 4435 |- | NOTA_FS2 || 93 || NOTA_E5 || 659 || NOTA_D8 || 4699 |- | NOTA_G2 || 98 || NOTA_F5 || 698 || NOTA_DS8 || 4978 |- | NOTA_GS2 || 104 || NOTA_FS5 || 740 || || |- | NOTA_A2 || 110 || NOTA_G5 || 784 || || |- | NOTA_AS2 || 117 || NOTA_GS5 || 831 || || |- | NOTA_B2 || 123 || NOTA_A5 || 880 || || |- | NOTA_C3 || 131 || NOTA_AS5 || 932 || || |- | NOTA_CS3 || 139 || NOTA_B5 || 988 || || |- | NOTA_D3 || 147 || NOTA_C6 || 1047 || || |- | NOTA_DS3 || 156 || NOTA_CS6 || 1109 || || |- | NOTA_E3 || 165 || NOTA_D6 || 1175 || || |- | NOTA_F3 || 175 || NOTA_DS6 || 1245 || || |- | NOTA_FS3 || 185 || NOTA_E6 || 1319 || || |- | NOTA_G3 || 196 || NOTA_F6 || 1397 || || |- | NOTA_GS3 || 208 || NOTA_FS6 || 1480 || || |} == Comentarios == * Puedes usar un potenciómetro de 10k en serie con una resistencia de 1k para controlar el volumen del altavos (parlante). * El rango auditivo humano es de aprox 20 kHz {| class="wikitable col1cen col2cen col3cen col4cen" |+Rango de frecuencias depende de frecuencia de uC |- ! Reloj uC !! Fmin con Temporizador 8 bits !! Fmin Temporizador de 16 bits !! Fmax |- | 8 MHz || 16 Hz || 1 Hz || 4 MHz |- | 16 MHz || 31 Hz || 1 Hz || 8 MHz |} == Advertencias == * Nunca conecte el pin Arduino directamente a una entrada de audio. El voltaje es considerablemente más alto que un voltaje de nivel de línea estándar y puede dañar las entradas de audio. Puede usar un divisor de tensión para adecuar la salida de Arduino a la entrada de audio. * Si usa un altavoz (parlante) DEBE poner una resistencia de 1K en serie o dañada la salida del Arduino. * Si asigna el Temporizador 0 afectara el uso [[analogWrite()|PWM]] y [[millis()]]. * La librería solo acepta números enteros positivos [[unsigned int]] como frecuencias. Osea la frecuencia máxima sera 65 535 Hz. == Ejemplo 1 == Toque una nota de 4° octava A (440 Hz) en el pin 13. <syntaxhighlight lang="c++"> #include <Tone.h> Tone pito; void setup(){ pito.begin(13); pito.play(NOTE_A4); } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == Escriba un boceto para leer una entrada analógica y asigne el resultado a un rango de 100 a 1000. Almacene el resultado en una variable local llamada frecuencia. Esta será la frecuencia que toque en el altavoz. Luego use el comando de [[tone()]] para configurar la frecuencia del altavoz en el pin digital 8 durante 10 ms. <syntaxhighlight lang="c++"> void setup() { //Nada } void loop() { int frecuencia = analogRead(A0); int valor = map(frecuencia, 200, 900, 100, 1000); tone(8, valor, 10); } </syntaxhighlight> == Ejemplo 3 == En telefonía, el sistema de marcación por tonos o DTMF (Dual-Tone Multi-Frequency) es usado para la señalización de telecomunicaciones sobre líneas telefónicas analógicas en la banda de frecuencia vocal entre teléfonos u otros equipos de comunicaciones y la central telefónica. <syntaxhighlight lang="c++"> #include <Tone.h> Tone freq1; Tone freq2; const int DTMF_freq1[] = { 1336, 1209, 1336, 1477, 1209, 1336, 1477, 1209, 1336, 1477 }; const int DTMF_freq2[] = { 941, 697, 697, 697, 770, 770, 770, 852, 852, 852 }; void setup(){ Serial.begin(9600); freq1.begin(11); freq2.begin(12); } void loop(){ uint8_t numero[] = {8, 6, 7, 5, 3, 0 , 9}; for (byte i=0; i<sizeof(numero); i++){ Serial.print(numero[i], 10); playDTMF(numero[i], 500); delay(600); } Serial.println(); delay(4000); } void playDTMF(uint8_t num, long duracion){ freq1.play(DTMF_freq1[num], duracion); freq2.play(DTMF_freq2[num], duracion); } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] [[Category:Librerias]] 22c5d9vlno3wofwws4er2jdloqqoutc 0 157 4663 3721 2019-07-07T01:01:04Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == == Código == <pre> </pre> == Comentarios == == Vea también == <categorytree mode=all>Ejemplo Digital</categorytree> == Referencias externas == [[Category:Ejemplo Digital]] pmpxks59ujkjcr350mr9p5wpists1qc 0 158 4676 4675 2019-07-07T01:07:21Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == == Código == <pre> </pre> == Comentarios == == Vea también == <categorytree mode=all>Ejemplo Digital</categorytree> == Referencias externas == [[Category:Ejemplo Digital]] pmpxks59ujkjcr350mr9p5wpists1qc 0 159 4681 4680 2019-07-07T01:09:17Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == == Código == <pre> </pre> == Comentarios == == Vea también == <categorytree mode=all>Ejemplo Digital</categorytree> == Referencias externas == [[Category:Ejemplo Digital]] 1v9i19jgpctozhitw3eglayaj8aj8i9 0 160 4679 4678 2019-07-07T01:08:31Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki Este ejemplo muestra cómo usar el comando de [[tone()]] para generar un tono que sigue los valores de una entrada analógica que tiene conectada una fotorresistencia. Pase la mano sobre la fotoresistencia para variar los tonos. == Circuito == Conecte un terminal de su altavoz al pin digital 9 (PWM) a través de una resistencia de 100 ohmios y su otro terminal a GND. Conecte su photoresistor entre +5V y el pin analógico A0 y añada una resistencia de 4K7 entre ese mismo pin analogico A0 y GND. == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> void setup() { Serial.begin(115200); } void loop() { //Photoresistor entre 400~1000 int sensor = analogRead(A0); Serial.println(sensor); //Rango de sonido entre 120~1500 Hz int toca = map(sensor, 400, 1000, 120, 1500); tone(9, toca, 10); delay(1); } </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Ejemplo Digital</categorytree> == Referencias externas == * [https://www.arduino.cc/en/Tutorial/TonePitchFollower Ejemplos incluidos] [[Category:Ejemplo Digital]] 3xmtnjtu5b267ekf8b9co9l8bz5ux8j 0 163 4091 4090 2019-05-31T00:09:22Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki En este ejemplo, con Ethernet Shield y su Arduino podrá enviar y recibir cadenas de texto a través del protocolo UDP (Universal Datagram Packet). Necesitará otro dispositivo para enviar y recibir mensajes. == Ejemplo == <syntaxhighlight lang="c++"> #include <Ethernet.h> #include <EthernetUdp.h> byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //Asignar MAc al modulo IPAddress ip(192, 168, 1, 177); //Asignar IP unsigned int localPort = 8888; //Asignar puerto a escuchar // buffers for receiving and sending data char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; // buffer to hold incoming packet, char ReplyBuffer[] = "acknowledged"; // a string to send back EthernetUDP Udp; //Instanciar UDP byte CS = 10; //Confugura CS para UNO //byte CS = 15; //Confugura CS para ESP8266 //byte CS = 33; //Confugura CS para ESP32 //byte CS = 5; //Confugura CS para MKR void setup() { Serial.begin(9600); Ethernet.init(CS); Ethernet.begin(mac, ip); //Iniciar Ethernet // Check for Ethernet hardware present if (Ethernet.hardwareStatus() == EthernetNoHardware) { Serial.println("Ethernet shield was not found. Sorry, can't run without hardware. :("); while (true) { delay(1); //do nothing, no point running without Ethernet hardware } } if (Ethernet.linkStatus() == LinkOFF) { Serial.println("Ethernet cable is not connected."); } Udp.begin(localPort); //Inicializa UDP } void loop() { // if there's data available, read a packet int packetSize = Udp.parsePacket(); if (packetSize) { Serial.print("Received packet of size "); Serial.println(packetSize); Serial.print("From "); IPAddress remote = Udp.remoteIP(); for (byte i=0; i<4; i++) { Serial.print(remote[i], DEC); if (i < 3) { Serial.print("."); } } Serial.print(", port "); Serial.println(Udp.remotePort()); // read the packet into packetBufffer Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE); Serial.println("Contents:"); Serial.println(packetBuffer); // send a reply to the IP address and port that sent us the packet we received Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); Udp.write(ReplyBuffer); Udp.endPacket(); } delay(10); } </syntaxhighlight> Para ejecutar con este ejemplo <syntaxhighlight lang="c++"> // Processing UDP example to send and receive string data from Arduino // press any key to send the "Hello Arduino" message import hypermedia.net.*; UDP udp; // define the UDP object void setup() { udp = new UDP( this, 6000 ); // create a new datagram connection on port 6000 //udp.log(true); // <-- printout the connection activity udp.listen(true); // and wait for incoming message } void draw() { //Nada } void keyPressed() { String ip = "192.168.1.177"; // the remote IP address int port = 8888; // the destination port udp.send("Hello World", ip, port ); // the message to send } void receive( byte[] data ) { // <-- default handler //void receive( byte[] data, String ip, int port ) { // <-- extended handler for (byte i=0; i<data.length; i++) print(char(data[i])); println(); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria Ethernet</categorytree> == Refrencias externas == [[Category:Libreria Ethernet]] 4nz5ekvgzmymjpb8000dp1o69dseasi 0 358 4969 4871 2019-09-26T16:10:44Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Arduino '''UNO''' es la mejor placa para comenzar a usar la electrónica y la codificación. Si esta es tu primera experiencia jugando con la plataforma Arduino, la '''UNO''' es la placa más robusta, usada y documentada de la familia. Esta basado en el uC ATmega328P de 8 bits a 16 MHz, perteneciente a la familia AVR de arquitectura RISC, 32 registros de trabajo, 3 temporizadores flexibles, UART serie, convertidos ADC de 14 canales de 10 bits. Encapsulado DIP de 28 pines. == Características == {|class="wikitable" |+Especificaciones técnicas !Parámetro!!Valor |- |uC||ATmega328P |- |Bus||8 bits |- |Velocidad||16Mhz |- |Memoria [[flash]]||32KB (0.5KB para arranque) |- |Memoria [[SRAM]]||2KB |- |Memoria [[EEPROM]]||1KB |- |Alimentación||5V |- |Entrada||7~12V |- |Entrada limite||6~20V |- |Pines digitales||14 (6 PWM de 8 bits) |- |Pines analógicos||6 |- |Corriente por pines||20 mA |- |[[LED_BUILTIN]]||13 |} == Pines == ;PWM: Algunos pines, marcados con un símbolo "~" en la placa, admiten [[analogWrite()|PWM]], es decir, impulsos rápidos que se pueden usar para controlar motores a varias velocidades o reproducir música (variando la frecuencia de pulso, modulación de ancho de pulso ). Son 3, 5, 6, 9, 10 y 11. Los pines 5 y 6 tienen una frecuencia de 980 Hz el resto de pines tienen una frecuencia de 490 Hz. ;USB: Universal Serial Bus. Se usa para comunicarse a través del protocolo USB con una computadora host (para programar o enviar / recibir datos en serie). Son Rx (0) y Tx (1), por lo que no se recomienda reasignarlos para otra función si requeriras usan el monitor serie por ejemplo. ;VCC: La línea de "potencia". Generalmente + 5V en el Arduino Uno. ;Vin: El voltaje en la placa. En general, esto será aproximadamente 0V7 menos que el voltaje suministrado la "clavija de alimentación" debido al diodo de protección de polaridad inversa. No se recomienda extraer energía de Vin si está alimentando el Arduino desde el puerto USB. ;5V:Fuente de maximo 50 mA ;3.3V:Fuente de maximo 50 mA ;GND:Tierra. ;RESET:Pin de reset ;IOREF:La referencia de tensión IO (conectada a + 5V). Destinado a permitir que los escudos (Sheeld) vean si la placa Arduino está funcionando a 5V o 3V3. ;AREF:Referencia de lectura analógica. ;ISCP:Esta placa Arduino posee una entrada ICSP (In Chip Serial Programmer) que tiene acceso a la memoria de programa del AVR (Flash), ésto es, que puede grabar directamente desde el PC al microcontrolador cualquier programa sin usar el puerto USB. Uno de ellos, el mismo Bootloader de Arduino. ;Interrupciones:Los pines digitales 2 y 3 corresponden a INT0 e INT1. == Pines digitales == * Existen 14 pines digitales (0~13) que pueden ser configurados como entrada o salida digital. * No debes meter o sacar mas de 40 mA en cada una. * 6 de ellos están marcados con '''~''' y pueden ser usados como [[analogWrite()|PWM]]. * Deben ser previamente configurados con [[pinMode()]]. == Pines analógicos == * Los pines marcados A0~A5 se usan para hacer lecturas "analógicas" que son codificadas via un ADC. * Usando la función [[analogRead()]] se obtiene lectura entre 0 (para 0V) y 1023 (para 5V). El rango puede alterarse mediante una programación adecuada y/o suministrando un voltaje diferente al pin '''AREF'''. * Aquí puede poner alguna fuente de voltaje (de 0 a 5 V) como una "referencia de voltaje" precisa para las llamadas a la función [[analogRead()]]. * Los pines analógicos A0~A5 también pueden usarse para lectura/escritura digital. Para este propósito, puede referirse a ellos como pines 14 a 19. <pre> pinMode(19, OUTPUT); digitalWrite(19, HIGH); </pre> == LEDs == * Tiene un LED incorporado llamado [[LED_BUILTIN]] en el pin digital 13. Cuando el pin 13 esta en HIGH prende. * Dos LEDs de transmision serie Tx/Rx. == Botones == * Tiene un botón reset. * Adicionalmente tiene un pin RST que con un LOW reiniciar el microcontrolador. Normalmente se usa para agregar un botón de reinicio con los modulos que bloquean el botón incorporado. == ICSP == * Exiten dos conectores ICSP uno conectado al ATmega328P y el otro al ATmega16U2. * Se usa para programar el uC ATmega328P principal (el más común) o el procesador de interfaz USB ATmega16U2 (solo si es necesario). * El sistema ICSP usa [[SPI]] con un protocolo integrado en los chips. {|class="wikitable" !pin!!Descripcion |- |1||MISO |- |2||5V |- |3||SCK |- |4||MOSI |- |5||RST |- |6||GND |} {{Nota|La programación también se realiza normalmente utilizando la interfaz serie asíncrona (pines D0 / D1) y un programa de gestor de arranque instalado.}} == Puerto serie == Los pines 0 (Rx) y 1 (Tx) se pueden usar para comunicaciones serie asíncronas. Estos pines también están conectados internamente a través de resistencias de 1K al chip USB, de modo que los datos de la interfaz USB se pueden enviar/recibir a los pines 0 y 1. {{Nota|La libreria [[SoftwareSerial]] permite la comunicación en serie por cualquiera de los pines digitales del Nano.}} == Bus I2C == Un protocolo '''Inter Integrated Circuit''' (también llamado TWI) usa una línea de reloj (SCL) junto con una línea de datos (SDA) para transferir información. Reloj serie ;SCL (Serial Clock Line): La línea de reloj. Pin A5. Usada por I2C para indicar datos está lista en la línea de datos. ;SDA (Serial Data Line): La línea de datos (bidireccional). Pin A4. Usada para datos seriales. {{Nota|Para saber mas consulta la libreria [[Wire]].}} == Bus SPI == Un protocolo '''Serial Peripheral Interface''' usa una línea de reloj (SCK) junto con datos de maestro a esclavo (MOSI) y esclavo a maestro (MISO) para transferir información. También se usa comúnmente una línea de selección de esclavos (SS) para seleccionar un esclavo de entre múltiples. ;SCK (Serial Clock): Pin 13. Una línea de reloj generada por el maestro para "reloj" de datos al esclavo. ;MOSI (Master Out, Slave In): Pin 12. Los datos van del maestro al esclavo. ;MISO (Master In, Slave Out): Pin 11. Los datos van del esclavo al maestro. ;SS (Slave Select): Pin 10. Usado para seleccionar un esclavo. Típicamente se baja para estar activo. {{Nota|Revisa la libreria [[SPI]] para saber como usarlo.}} == Rangos máximos == Los pines IO tienen una calificación máxima absoluta de 40 mA por pin. Sin embargo, en la práctica, debe diseñar para que una clasificación de 20 mA sea segura. Además, los siguientes grupos de pines no deben hundirse más de 100 mA (cada grupo): * Pines digitales del D0 a D4 * Pines digitales del D5 al D13 * Pines analógicos del A0 a A5 {|class="wikitable col1cen" |+Banco de puertos ATmega328p !Puerto!!2⁷!!2⁶!!2⁵!!2⁴!!2³!!2²!!2¹!!2⁰ |- |B||||||D13||D12||D11||D10||D9||D8 |- |C||||||A5||A4||A3||A2||A1||A0 |- |D||D7||D6||D5||D4||D3||D2||D1||D0 |- !Puerto!!128!!64!!32!!16!!8!!4!!2!!1 |} Además de eso, todo el chip del procesador tiene una calificación máxima de consumo de corriente de 200 mA. Estas cifras generalmente se refieren a los pines en el modo de salida (el modo de entrada no consumirá mucha potencia). De modo que puede ver que, configurados como salidas, solo podría tener 10 pines que suministran 20 mA cada uno (para evitar exceder el máximo del chip) e incluso entonces tendrían que extenderse para que no consuma más de 100 mA de un grupo mencionado anteriormente. == Resistencias limitadoras de corriente == * Como regla general, si conecta un LED a un pin digital configurado como salida, querrá algo así como una resistencia de 330 ohm en serie con el diodo. * Esto se debe a que desea extraer algo así como 10 mA de corriente, con una caída de voltaje de 3V3 (el diodo cae 1V7, por lo que la resistencia suelta los otros 3V3 de un suministro de 5V). Usando la ley de Ohms, 3.3 / 0.010 = 330 ohmios. {{Nota|Incluso una resistencia de 1K proporciona una salida de LED razonablemente brillante, y solo consume alrededor de 3.3 mA.}} == Fuente de alimentación == La placa se puede alimentar desde el conector USB para probar mientras está conectado a una computadora o con una fuente de 5V. Si usa un suministro externo, se recomienda un rango de voltaje entre 7~12V (por ejemplo, se podría usar una batería de 9V). Use la clavija. Tenga en cuenta que cuanto mayor sea el voltaje, más trabajo debe hacer el regulador de voltaje para "tirar" el exceso de voltaje, de modo que con un suministro de 12V o mas y alimentando bastantes "periféricos", es probable que el regulador de voltaje se caliente. Por otro lado, el circuito interno está diseñado para cambiar de USB a externo si el suministro externo excede 6V6, por lo que el suministro de mucho menos de 7V probablemente no funcionará correctamente. == Polifusible == El Arduino UNO R3 tiene un polifusible reseteable que protege el puerto USB (pin 1 de +5V) de su computadora contra cortos y sobrecargas. Si se extrae más de 500 mA del puerto USB, el fusible se cortara automáticamente hasta que se elimine el cortocircuito o la sobrecarga. Tipo MSMF050-2. == Vea también == * [[MINI]] * [[MICRO]] * [[NANO]] * [[MEGA]] * [[DUE]] * [[101]] * [[LEONARDO]] * [[MKR1000]] * [[NodeMCU]] - ESP8266 == Referencias externas == * [https://www.arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-schematic.pdf Esquema] * [https://www.arduino.cc/en/Hacking/Atmega168Hardware ATmega168 pin mapping] - Arduino * [http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_Datasheet.pdf Datasheat 328P] - Microchip * [http://www.gammon.com.au/uno Arduino UNO] - Nick Gammon * [https://www.luisllamas.es/esquema-de-patillaje-de-arduino-pinout/ Esquema de patillaje de Arduino] - Luis Llamas * [http://manueldelgadocrespo.blogspot.com/p/modelos_29.html Modelos de Arduino] - Manuel Delgado * [https://descubrearduino.com/elegir-la-placa-arduino-adecuada-para-tu-proyecto-una-introduccion/ Que modelo comprar] - Descubre Arduino * [https://aprendiendoarduino.wordpress.com/2016/11/06/hw-arduino-a-fondo/ Arduino a fondo] - Enrique Crespo * [http://diymakers.es/guia-arduino/ Guia Arduino] - Diy Makers [[Category:Placas]] oqwk6lmh0pf35cf3yj342wkfr9f9yye 0 3 5246 5245 2020-02-04T01:34:54Z Kike GL 2 /* Constantes */ wikitext text/x-wiki Una variable es una palabra que representa un espacio de memoria que fue reservado expresamente durante su '''declaracion''' asignándole un tipo de dato. Al mismo tiempo o posteriormente se puede '''inicializar''' con un valor dicha variable. <pre> tipo nombre [= valor]; </pre> == Alcance o ámbito == Las variables en el lenguaje de programación C++, que usa Arduino, tienen una propiedad llamada '''ámbito'''. Esto está en contraste con las primeras versiones de lenguajes de programación como BASIC, donde todas las variable siempre son del tipo [[variable publica|global]]. * Una variable [[variable publica|global]] es aquella que puede ser vista por cada función en un [[boceto]]. En el entorno Arduino, cualquier variable declarada fuera de una función (por ejemplo, [[setup()]], [[loop()]] o función de usuario), es una variable global. * Las variables '''locales''' solo son visibles para la función en la que están declaradas. Cuando un [[boceto]] comienza a hacerse más grande y complejo, las [[variable local|variables locales]] son una forma útil de asegurar que cada función tenga acceso a sus propias variables. Esto evita errores de programación cuando una función modifica inadvertidamente variables usadas por otra función. También es útil a veces '''declarar e inicializar''' una variable dentro de un bucle [[for]]. Esto crea una variable a la que solo se puede acceder desde dentro de las llaves del bucle [[for]]. == Tipos de dato == Estos son los tipos de datos que usa Arduino. {|class="wikitable" |+Tipos de dato en Arduino !Tipo!!Ocupa!!Rango |- |[[char]]||1 byte (8 bits)||-128 a 127 |- |[[byte]]||1 byte (8 bits)||0 a 255 |- |[[int]]||2 byte (16 bits)||-32,768 a 32,767 |- |[[unsigned int]] o [[word]]||2 byte (16 bits)||0 a 65,535 |- |[[long]]||4 byte (32 bits)||-2,147,483,648 a 2,147,483,647 |- |[[unsigned long]]||4 byte (32 bits)||0 a 4,294,967,295 |- |[[float]]||4 byte (32 bits)||-3.4E38 a 3.4E38 |} === Numéricos === * [[char]] * [[byte]] * [[int]] * [[unsigned int]] * [[long]] * [[unsigned long]] * [[float]] * [[double]] - solo [[MEGA]] * [[word]] === Fecha y hora === * [[time_t]] - TimeLib.h * [[tmElements_t]] - TimeLib.h * [[DateTime]] - RTClib.h {{Nota|Si usas la librería TimeLib.h puedes usar los tipos: '''time_t''' y '''tmElements_t'''}} === Caracteres === * [[string]] - matriz * [[String]] - clase === Otros === * [[bool]] * [[void]] == Utilidades == * [[sizeof()]] * [[PROGMEM]] * [[F()]] * [[EEPROM]] == Calificadores == En ocaciones es necesario calificar una variable de modo que le indicas en que tipo de memoria deberá ser almacenada: [[flash]], [[SRAM]] o [[EEPROM]]. * [[const]] * [[static]] * [[volatile]] * [[extern]] * [[define|#define]] == Matrices == La [[matriz]] o array es un tipo especial de variable múltiple. Puede ser uni o bidimencional. <pre> tipo matriz[] = {valor1, valor2...}; tipo matriz[][n] = {valor11, valor12...},{valor21, valor22...}...; </pre> {{Nota|Si la matriz en '''bidimencional''' NO puede dejar de expresar el segundo vector}} == Palabras reservadas == Estas son palabra reservadas que tiene un significado especial y no pueden ser usadas como nombres de variable: <categorytree mode=all>Palabras reservadas</categorytree> * [[MSBFIRST / LSBFIRST]] {{Nota|En el [[IDE]] veras que estas palabras se pintan de color azul si están bien escritas.}} == Vea también == * [[Estructura]] * [[Funciones]] == Referencias == * [https://aprendiendoarduino.wordpress.com/2017/06/21/arrays-y-strings-2/ Arrays y string] - Enrique Crespo [[Category:Referencias]] qw721tk4vy2ekg0lvtvi05zaq4h1l16 0 242 3752 1012 2019-05-06T22:14:55Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Comunicaciones</categorytree> == Referencias == [[Category:Comunicaciones]] d8atefw72kf74bl7caf89mtyl0c79fx 0 142 4084 4083 2019-05-30T23:03:08Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Este ejemplo muestra cómo hacer una solicitud HTTP usando un modulo (sheald) de Ethernet. Devuelve una búsqueda en Google del término "Arduino". Los resultados de esta búsqueda se envían por monitor serie de Arduino. == Codigo == <syntaxhighlight lang="c++"> #include <SPI.h> #include <Ethernet.h> //Ethernet shield attached to pins 10, 11, 12, 13 byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //MAC del modulo IPAddress ip(192, 168, 0, 177); //IP del modulo char server[] = "www.google.com"; //Google (usar DNS) //IPAddress server(74,125,232,128); //IP de Google (no usar DNS) EthernetClient client; //Iniciar cliente void setup() { Serial.begin(9600); // start the Ethernet connection: if (Ethernet.begin(mac) == 0) { Serial.println("Failed to configure Ethernet using DHCP"); // try to congifure using IP address instead of DHCP: Ethernet.begin(mac, ip); } // give the Ethernet shield a second to initialize: delay(1000); Serial.println("connecting..."); // if you get a connection, report back via serial: if (client.connect(server, 80)) { Serial.println("connected"); // Make a HTTP request: client.println("GET /search?q=arduino HTTP/1.1"); client.println("Host: www.google.com"); client.println("Connection: close"); client.println(); }else { // if you didn't get a connection to the server: Serial.println("connection failed"); } } void loop() { // if there are incoming bytes available // from the server, read them and print them: if (client.available()) { char c = client.read(); Serial.print(c); } // if the server's disconnected, stop the client: if (!client.connected()) { Serial.println(); Serial.println("disconnecting."); client.stop(); // do nothing forevermore: while (true); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria Ethernet</categorytree> == Referencias == * [https://www.arduino.cc/en/Reference/EthernetClient Ethernet Client] [[Category:Ejemplos]] [[Category:Libreria Ethernet]] ld5hdvya06yxgpdsiml7bp46si3dgh3 0 488 4911 4910 2019-09-19T16:03:14Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki Este ejemplo muestra cómo hacer un envio de datos hacia un servidor Xampp (Apache + MySQL) == Código Arduino == <syntaxhighlight lang="c++"> #include <SPI.h> #include <Ethernet.h> byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED}; IPAddress server(192,168,0,20); EthernetClient client; int pot; void setup() { Serial.begin(9600); if (Ethernet.begin(mac) == 0) { Serial.println("Fallo la configuracion DHCP"); //Hacerlo para siempre for(;;) ; } delay(1000); Serial.println("conectando..."); if (client.connect(server, 80)) { Serial.println("conectado"); //Requerimiento: client.print("GET /arduino/mysql.php?valor="); pot = analogRead(A0); client.print(pot); client.println(" HTTP/1.0″); //client.println("GET /arduino/ethernet.php HTTP/1.0"); client.println(); } else { Serial.println("Fallo la coneccion"); } } void loop(){ //Si hay un cliente imprime sus datos if (client.available()) { char c = client.read(); Serial.print(c); } //Si el servidor se desconecta, para cliente if (!client.connected()) { Serial.println(); Serial.println("desconectando..."); client.stop(); //Hacerlo para siempre for(;;) ; } } </syntaxhighlight> == Código PHP == <syntaxhighlight lang="PHP"> $db = 'tiempos'; $mysqli = new mysqli('localhost', 'Usuario', 'Clave', $db) OR exit('Fallo al conectar a MySQL o BD'); $sql = 'INSERT INTO tabla1 SET val='. $_REQUEST['valor']; //echo $sql; $res = $mysqli->query($sql) OR exit('Revisa el query<p>'. $sql); if ($mysqli->affected_rows != 1){ echo 'Error...'; } //Cierra conexión $mysqli->close(); </syntaxhighlight> == MySQL == {| class="wikitable" |+Campos de tabla1 |- !Nombre!!Tipo!!Comentario |- |id||int(11)||Auto_Incremet |- |val||varchar(4)|| |- |fecha||datetime||Current_timestamp |} == Vea también == <categorytree mode=all>Libreria Ethernet</categorytree> == Referencias externas == * [http://panamahitek.com/conectar-arduino-base-datos-mysql/ Conectar Arduino con MySQL] - Panama Hitek * [https://www.rinconingenieril.es/arduino-ethernet-y-mysql/ Arduino a MySQL] - Rincon Ingenieril * [https://www.apachefriends.org/es/index.html Apache + MySQL + PHP] - Apache friends [[Category:Ejemplos]] [[Category:Libreria Ethernet]] rgcb4gg7g9mj8asw0jzb7tqt8ap11eq 0 143 4079 4078 2019-05-30T22:55:13Z Kike GL 2 /* Codigo */ wikitext text/x-wiki Este ejemplo muestra cómo realizar solicitudes HTTP repetidas utilizando un escudo Ethernet. Este ejemplo utiliza DNS, asignando al cliente Ethernet una dirección MAC, una dirección IP y una dirección DNS. Se conecta a http://www.arduino.cc/latest.txt. El contenido de la página se puede ver a través de la ventana serie de Arduino. == Codigo == <syntaxhighlight lang="c++"> #include <SPI.h> #include <Ethernet.h> //Ethernet shield attached to pins 10, 11, 12, 13 byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; //Asigna una MAC al modulo IPAddress ip(192, 168, 1, 177); //Asigna un IP libre IPAddress myDns(1, 1, 1, 1); //Asigna tu servidor DNS EthernetClient client; //Inicializa cliente char server[] = "www.arduino.cc"; //IPAddress server(64,131,82,241); unsigned long lastConnectionTime = 0; //Ultima conexion const unsigned long postingInterval = 10L * 1000L; //Retardo entre actualizaciones void setup() { Serial.begin(9600); delay(1000); Ethernet.begin(mac, ip, myDns); //Inicia conexion Ethernet Serial.print("Mi direccion IP: "); Serial.println(Ethernet.localIP()); } void loop() { if (client.available()) { char c = client.read(); Serial.write(c); } if (millis() - lastConnectionTime > postingInterval) { httpRequest(); } } void httpRequest() { client.stop(); //Cierra conexion y libera socket if (client.connect(server, 80)) { Serial.println("conectando..."); client.println("GET /latest.txt HTTP/1.1"); //Envia requerimiento HHTTP GET client.println("Host: www.arduino.cc"); client.println("User-Agent: arduino-ethernet"); client.println("Connection: close"); client.println(); lastConnectionTime = millis(); }else{ Serial.println("conexion fallo."); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria Ethernet</categorytree> == Referencias externas == * [http://www.arduino.cc/en/Tutorial/WebClientRepeating Web Client Repeating] [[Category:Ejemplos]] [[Category:Libreria Ethernet]] bf3d85810fghv8fotatjvxnsvo6c413 0 162 4097 4092 2019-05-31T00:39:26Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki En este ejemplo, con Ethernet Shield y Arduino se crea un servidor web simple. Con la biblioteca Ethernet, su dispositivo podrá responder a una solicitud HTTP. Después de abrir un navegador y navegar a la dirección IP de su escudo Ethernet, su Arduino responderá con HTML para que un navegador muestre los valores de entrada de los seis pines analógicos. == Ejemplo == <syntaxhighlight lang="c++"> #include <SPI.h> #include <Ethernet.h> byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //Asignar MAC al modulo IPAddress ip(192, 168, 1, 177); //Asignar IP al servidor //Ethernet shield attached to pins 10, 11, 12, 13 //Analog inputs attached to pins A0 through A5 (optional) EthernetServer server(80); //Inicializa Ethernet void setup() { Serial.begin(9600); Serial.println("Ejemplo Servidor Web"); Ethernet.begin(mac, ip); //Inicializa Ethernet // Check for Ethernet hardware present if (Ethernet.hardwareStatus() == EthernetNoHardware) { Serial.println("Modulo Ethernet no encointrado. No podemos hacer nada sin hardware."); while (true) { delay(1); //do nothing, no point running without Ethernet hardware } } if (Ethernet.linkStatus() == LinkOFF) { Serial.println("Conecta el cable RJ-45 en el modulo."); } server.begin(); //Inicializa servidor Serial.print("El servidor este en IP: "); Serial.println(Ethernet.localIP()); } void loop() { EthernetClient client = server.available(); //Esperando algún cliente if (client) { Serial.println("Nuevo cliente"); boolean blanco = true; while (client.connected()) { if (client.available()) { char c = client.read(); Serial.write(c); if (c == '\n' && blanco) { client.println("HTTP/1.1 200 OK"); //Envia respuesta estandar client.println("Content-Type: text/html"); client.println("Connection: close"); //Cierra la conexion luego de completar client.println("Refresh: 5"); //Refresca pagina automaticamente cada 5 sec client.println(); client.println("<!DOCTYPE HTML>"); client.println("<html><body>"); //Lee todo los puertos análogos for (byte pin=0; pin<6; pin++) { int sensorReading = analogRead(pin); client.print("analog input "); client.print(pin); client.print(" is "); client.print(sensorReading); client.println("<br />"); } client.println("</body></html>"); break; } if (c == '\n') { blanco = true; }else if (c != '\r') { blanco = false; } } } delay(1); client.stop(); //Cierra conexion del cliente Serial.println("cliente desconectado."); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria Ethernet</categorytree> == Referencias == [[Category:Ejemplos]] [[Category:Libreria Ethernet]] ezc1ku0axy0ec59cb2z3u8v3ua5ewh2 0 249 3758 1083 2019-05-06T22:18:05Z Kike GL 2 /* Vea también */ wikitext text/x-wiki Algunas veces quiere que todo en el boceto se detenga mientras una condición dada es verdadera. Puedes hacer esto usando un bucle [[while]]. Este ejemplo muestra cómo usar un bucle [[while]] para calibrar el valor de un sensor analógico. En el bucle principal, del siguiente boceto lee el valor de una fotorresistencia en el pin analógico A0 y lo usa para prender un LED en el pin 9. Pero mientras se presiona un botón conectado al pin digital 2, el boceto ejecuta una funcion de usuario llamado '''calibra()''' que busca los valores más altos y más bajos del sensor analógico. Cuando sueltas el botón, el boceto continúa con el ciclo principal. {{Nota|Esta técnica le permite actualizar los valores máximos y mínimos para el fotoresistor cuando cambian las condiciones de iluminación.}} == Placa aplicable == Todas. == Código == <syntaxhighlight lang="c++"> const byte sensor = A0; const byte pulsador = 2; const byte led = 9; //Valores sensor int min = 511; int max = 512; void setup() { pinMode(LED_BUILTIN, OUTPUT); pinMode(led, OUTPUT); pinMode(pulsador, INPUT_PULLUP); } void calibra() { digitalWrite(LED_BUILTIN, HIGH); //Prende modo calibracion int actual = analogRead(sensor); //Lee sensor: //Guarda maximo if (actual > max) { max = actual; } //Guarda minimo if (actual < min) { min = actual; } } void loop() { //Mientras esta pulsado calibramos sensor while (digitalRead(pulsador) == LOW) { calibra(); } digitalWrite(LED_BUILTIN, LOW); //Fin modo calibración int actual = analogRead(sensor); //Lee sensor //Aplica calibración de sensor sensorValue = map(actual, min, max, 0, 255); sensorValue = constrain(sensorValue, 0, 255); //Restringe rango analogWrite(led, sensorValue); //PWM al LED externo } </syntaxhighlight> == Comentarios == == Vea también == <categorytree mode=all>Estructuras de control</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/WhileStatementConditional Ejemplos incluidos] [[Category:Estructuras de control]] n6igkhs9fyoy7qpq2mgc42iqf34uxr9 0 120 5278 4895 2020-03-16T17:19:11Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == La librería [https://github.com/arduino-libraries/WiFi WiFi] de Arduino... {{Tip|Librería oficial, es decir que está preinstalada junto con la IDE de Arduino, no es necesario descargarla.}} == Placas aplicables == == Sintaxis == <pre> </pre> == Métodos == {|class="wikitable" |+Metodos WiFi !Metodo!!Descripcion |- |ping(ip)|| |- |begin(ip, ttl)|| |} == Comentarios == == Advertencias == == Ejemplo == Con este ejemplo logras prender y apagar un LED desde la pagina web alojada en el nodeMCU. <syntaxhighlight lang="c++"> #include <ESP8266WiFi.h> #include <ESP8266WebServer.h> const char* ssid = "MIRED"; //Nombre SSID const char* password = "12345678"; //Clave IPAddress local_ip(192,168,2,100); IPAddress gateway(192,168,2,1); IPAddress subnet(255,255,255,0); ESP8266WebServer server(80); bool LEDstatus = LOW; void setup() { Serial.begin(9600); pinMode(D5, OUTPUT); WiFi.softAP(ssid, password); WiFi.softAPConfig(local_ip, gateway, subnet); delay(100); server.on("/", handle_OnConnect); server.on("/ledon", handle_ledon); server.on("/ledoff", handle_ledoff); server.onNotFound(handle_NotFound); server.begin(); Serial.println("Servido HTTP iniciado"); } void loop() { server.handleClient(); if (LEDstatus){ digitalWrite(D5, HIGH); }else{ digitalWrite(D5, LOW); } } void handle_OnConnect() { LEDstatus = LOW; server.send(200, "text/html", SendHTML(false)); } void handle_ledon() { LEDstatus = HIGH; server.send(200, "text/html", SendHTML(true)); delay(3000); LEDstatus = LOW; } void handle_ledoff() { LEDstatus = LOW; server.send(200, "text/html", SendHTML(false)); } void handle_NotFound(){ server.send(404, "text/plain", "Not found"); } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduinolibraries.info/libraries All Libraries] * [http://www.arduino.cc/en/Reference/WiFi WiFi] * [https://programarfacil.com/blog/arduino-inalambrico/ Arduino Inalambrico] - Luis Del Valle [[Category:Librerias]] 2vjo72x76fyvs17eqkpyqkeo20dvgp3 0 114 4764 4536 2019-07-15T22:24:27Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == La librería '''Wire.h''' estandar de Arduino le permite comunicarse con dispositivos por bus '''I2C''' (Inter-Integrated Circuit o 2 alambres). Usa dos lineas: SDA (datos) y SCL (reloj). Une los GND. El bus I2C es extremadamente útil para conectar múltiples dispositivos, ya que todos pueden compartir los mismos dos cables (más la tierra claro). Esto se debe a que los dispositivos son "direccionables". Cada dispositivo debe tener una dirección única en el rango de 8 a 119. La dirección 0 está reservada como una dirección de "transmisión", las direcciones 1 a 7 están reservadas para otros fines y las direcciones 120 a 127 están reservadas para uso futuro. Debido a esto puede tener una pantalla LCD en la dirección 10, otro arduino en la direccion 11 y un sensor en la direccion 12. {{Nota|A partir de Arduino 1.0, la biblioteca hereda de la clase [[Stream]], lo que la hace compatible con otras bibliotecas de lectura/escritura. Debido a esto, send() y receive() han sido reemplazados por read() y write().}} == Placas aplicables == {| class="wikitable col2cen col3cen" !Arduino!!Pin SDA!!Pin SCL |- ||UNO, Ethernet||A4||A5 |- ||MEGA||20||21 |- ||Leonardo||2||3 |- ||Debido||20||21 |} {{Nota|A diferencia de la mayoría de los Arduinos, el '''ESP8266''' no tiene un hardware TWI, por lo que I²C esta implementado por software. Esto significa que puedes usar cualquier pin GPIO. De forma predeterminada, Wire.begin() asignara los pines 4 (SDA) y 5 (SCL), pero puede especificar otros pines usando Wire.begin(SDApin, SCLpin).}} == Sintaxis == <pre> #include <Wire.h> Wire.begin(); </pre> == Métodos == {| class="wikitable" |+Metodos disponible librería Wire.h |- ! Métodos !! Descripción |- |Wire.begin(num) o Wire.begin(SDApin, SCLpin)||Inicie la libreria Wire y únase al bus I2C como maestro o esclavo. Esto normalmente debería llamarse solo una vez. En caso de varios esclavos es importante numerarlos (8~119). |- |Wire.beginTrasnmission(num)||Comience una transmisión al dispositivo esclavo '''num'''. Posteriormente, coloque los bytes en cola para la transmisión con la función Wire.write() y transmítalos llamando a Wire.endTransmission(). |- |Wire.read()||Lee un byte de dato desde el buffer que envío un maestro. |- |Wire.write(dato, longitud)||Pone en el buffer del maestro un byte de datos para ser transmitido a un esclavo. |- |Wire.onReceive(evento)||Interrupción para recibir datos. Evento es una función de usuario. |- |Wire.onRequest(evento)||Interrupción para transmitir datos. Evento es una función de usuario. |- |Wire.endTransmission()||Termina comunicación y libera pines. Devuelve 0 si la transmisión tubo éxito. |} == Proceso == # La transmisión empieza con la "condición de inicio", esto es cuando SDA esta en LOW y SCL esta en HIGH. # La direccion consta de 7 bits esta desplazada al MSB. De modo que el LSB tendra 0 = escritura o 1 = lectura (maestro a esclaveo). # Luego, el maestro espera a que el esclavo tire de la línea SDA a LOW, lo cual es un ACK (confirmación) de que existe un esclavo en esa dirección y está listo para recibir datos. Si no hay ningún esclavo conectado y encendido o si no tiene la dirección requerida, ignorará la preticion, dejando la línea SDA HIGH. Esto cuenta como un NAK (reconocimiento negativo). # Luego se transmite el [[byte]] de datos, el bit más significativo (MSB) primero. # Después de los 8 bits de datos, el maestro verifica que el esclavo confirma tirando de la línea SDA LOW. Así, se reconoce cada byte. # La transmisión finaliza con la "Condición de parada", esto es cuando SDA esta en HIGH y SCL esta en HIGH. == Velocidad de reloj == Se puede varias la velocidad de reloj así: {| class="wikitable col1cen col2cen col3cen" |- ! TWBR !! Pre-escaler !! Frecuencia !! Comentario |- | 12 || 1 || 400 kHz || Maxima soportada |- | 32 || 1 || 200 kHz || |- | 72 || 1 || 100 kHz || Default |- | 152 || 1 || 50 kHz || |- | 78 || 4 || 25 kHz || |- | 158 || 4 || 12.5 kHz || |} Para configurar el pre-escaler en 4 (12.5 kHz): <pre> Wire.begin(); TWBR = 158; TWBR |- bit (TWPS0); </pre> == Direcciones == * Las direcciones I2C son de 7 bits para identificar a los esclavos ya que el 8vo bit determina si se está escribiendo o leyendo. * Con 7 bits se puede obteniendo direcciones entre 0~127. Sin embargo, las direcciones de 0~7 y 120~127 están reservados. * En caso de tener mas de un esclavo se deben numerar (8~119) con Wire.begin(num_esclavo) y para transmitir el maestro debe identificar con Wire.begin Transmission(num_esclavo). 0 = todos los esclavos. * Si ve una dirección mayor que 127 (0x7F), entonces esa es la dirección de 8 bits, que incluye el LSB (lectura/escritura). Debe dividir esa dirección de 8 bits entre dos y desplazar una posición a la derecha () para obtener la dirección correcta para la biblioteca de '''Wire'''. Por ejemplo, si una hoja de datos dice usar la dirección 192 (0xC0) para escribir y 193 (0xC1) para leer, esa es una dirección de 8 bits. Divida 192 entre dos y la dirección "real" sera 96 (0x60). == Comentarios == La libreria estándar de I2C para Arduino es '''Wire'''. Si bien esta libreria es suficiente la mayor parte del tiempo cuando desea comunicarse con dispositivos, hay situaciones en las que no es aplicable: * Los pines de I2C (SDA/SCL) ya están en uso para otros fines, * el código se ejecutará en un procesador ATtiny con 1 MHz en pines arbitrarios, * tiene poca memoria (flash y RAM), o * no desea usar las resistencias de activación habilitadas implícitamente porque sus dispositivos se ejecutan con 3 voltios. Se adapto la libreria I2C de Peter Fleury que está escrito en ensamblador AVR, de peso extremadamente ligero (< 500 bytes de flash) y muy rápido. Incluso con un ATtiny de 1 MHz, uno todavía puede operar el bus con 33 kHz, lo que implica que puede controlar dispositivos esclavos que usan el protocolo SMBus (tiempo de espera si la frecuencia del bus es inferior a 10 kHz). Si desea que se ejecute una solución en una MCU ARM (Due, Zero, Teensy 3.x), desea usar los pines en el puerto H o superior en un ATmega256, o si desea usar muchos buses I2C diferentes, esta biblioteca no es la solución adecuada para usted. En estos casos recomiendo [https://github.com/felias-fogg/SlowSoftI2CMaster SlowSoftI2CMaster], otra libreria I2C escrita en C++. {{Nota|Recuerde que Arduino UNO R3 tiene I2C dedicado adicional en los pines debajo del USB.}} == Advertencias == * Las direcciones I2C son de 7 bits para identificar a los esclavos ya que el 8vo bit determina si se está escribiendo o leyendo. * Con 7 bits se puede obteniendo direcciones entre 0~127. Sin embargo, las direcciones de 0~7 y 120~127 están reservados. * En caso de tener mas de un esclavo se deben numerar (8~119) con Wire.begin(num_esclavo) y para trasnmitir el maestro debe indentificar con Wire.begin Transmission(num_esclavo). 0 = todos los esclavos. * Si tienes mas de un esclavo o usa cables largos, hay que poner un 4k7 como pull-up en cada linea SDA/SCL. * No olvide conectar también todos los GND. * El buffer es de 32 bytes. {{Nota|Recuerde que se transmite un byte a la vez, por lo que para transmitir un int (2 byte) o un long (4 bytes) se debera hechar mano a las funciones lowByte(), highByte(), bitshift left (<nowiki><<</nowiki>), bitshift right (<nowiki><>></nowiki>), asi como los operadores bit a bit compuestos como: <nowiki>|=</nowiki>, <nowiki>&=</nowiki>, <nowiki>>>=</nowiki>, <nowiki><<=</nowiki>; tanto en el emisor como el receptor.}} == Ejemplo 1 == <syntaxhighlight lang="c++"> #include <Wire.h> byte valor = 0 ; void setup() { Wire.begin(); //unirse al bus i2c (dirección opcional para el maestro) TWBR = 12; //Aumenta velocidad de reloj 4 veces } void loop() { Wire.beginTransmission(44); //transmitir al dispositivo N° 44 (0x2c) //la dirección del dispositivo se especifica en la hoja de datos Wire.write(byte (0x00)); //envía un byte de instrucción Wire.write(valor); //envía el valor del potenciómetro Byte if (Wire.endTransmission() == 0){ //deja de transmitir, 0 es exito val ++; //incrementa el valor if (valor == 64){ //si se alcanza la posición 64 (max) valor = 0 ; //comienza desde el valor más bajo } }else{ //Error } delay(500) ; } </syntaxhighlight> == Ejemplo 2 == Conectar dos Arduinos y que el maestro envie una secuencia y el esclavo la ejecute. En este caso usaremos 3 LED en los pines 11, 12 y 13 del esclavo. En el maestro ponemos este código. <syntaxhighlight lang="c++"> #include <Wire.h> const byte pin[] = {11, 12, 13}; byte estado = 0; void setup() { Wire.begin(); //Iniciamos maestro } void loop() { for (byte i=0; i<3; i++){ Wire.beginTransmission(1); //Nos queremos comunicar con el esclavo 1 Wire.write(pin[i]); //Enviamos primer byte, será el pin a encender Wire.write(estado); //Enviamos segundo byte, sera el estado 0/1 Wire.endTransmission(); //Paramos la transmisión delay(1000); } if (estado == 0){ estado = 1; }else{ estado = 0; } } </syntaxhighlight> Para el '''esclavo''' tendremos: <syntaxhighlight lang="c++"> #include <Wire.h> void setup() { Serial.begin(9600); pinMode(11, OUTPUT); pinMode(12, OUTPUT); pinMode(13, OUTPUT); Wire.begin(1); //Unimos este dispositivo al bus I2C con dirección 1 Wire.onReceive(recive); //Evento a ejecutar al detectar recepcion } void loop() { delay(100); } //Función que se ejecuta cada Wire.endTransmission() del maestro para recibir lo que manda con Wire.write(). void recive() { byte pin = 0; byte estado = 0; if (Wire.available() == 2){ pin = Wire.read(); //Leemos primer byte que sera pin Serial.print("LED: "); Serial.println(pin); estado = Wire.read(); //Leemos segundo byte que sera estado Serial.print("Estado: "); Serial.println(estado); } digitalWrite(pin, estado); //Prende o apagar LED } </syntaxhighlight> == Ejemplo 3 == En este ejemplo ilustramos como un maestro puede solicitar datos de un esclavo. Código maestro: <syntaxhighlight lang="c++"> #include <Wire.h> const byte esclavo = 42; enum { CMD_ID = 1, CMD_READ_A0 = 2, CMD_READ_D13 = 3 }; void setup (){ Serial.begin(9600); Wire.begin(); sendCommand(CMD_ID, 1); if (Wire.available()) { Serial.print("Id del esclavo: "); Serial.println(Wire.read(), DEC); }else{ Serial.println ("No responde el esclavo"); } } void loop(){ int val; sendCommand(CMD_READ_A0, 2); val = Wire.read(); //Recuperamos MSB val <<= 8; //Desplazamos 8 bits a la izquierda val |= Wire.read(); //Recuperamos LSB Serial.print("Valor sensor en A0 del esclavo: "); Serial.println(val); sendCommand(CMD_READ_D13, 1); val = Wire.read(); Serial.print("Estado del pin D13 del esclavo: "); Serial.println(val); delay(500); } void sendCommand (const byte cmd, const byte largo){ Wire.beginTransmission(esclavo); Wire.write(cmd); Wire.endTransmission(); Wire.requestFrom(esclavo, largo); //No continua hasta que tenga datos en el buffer } </syntaxhighlight> Código esclavo: <syntaxhighlight lang="c++"> #include <Wire.h> const byte esclavo = 42; char comando = 0; enum { CMD_ID = 1, CMD_READ_A0 = 2, CMD_READ_D13 = 3 }; void setup(){ pinMode(13, INPUT_PULLUP); //Pulsador pinMode(A0, INPUT); //Sensor analogico Wire.begin(esclavo); //Numero del esclavo Wire.onReceive(leer); //Cuando llega mensaje Wire.onRequest(pedir); //Cuando maestro solicita mensaje } void loop(){ //Nada } void sensor(const byte pin){ int val = analogRead(pin); byte buf[2]; buf[0] = highByte(val); //Capturamos MSB byte buf[1] = lowByte(val); //Capturamos LSB byte Wire.write(buf, 2); //Envia los 2 byte del sensor en A0 } void leer(){ comando = Wire.read(); } void pedir(){ switch (comando){ case CMD_ID: Wire.write(42); //Envia numero del esclavo break; case CMD_READ_A0: sensor(A0); //Envia dato sensor en A0 break; case CMD_READ_D13: Wire.write(digitalRead(13)); //Envia estado de pin 13 break; } } </syntaxhighlight> == Ejemplo 4 == En este ejemplo queremos saber que esclavos estan activos. Código maestro: <syntaxhighlight lang="c++"> #include <Wire.h> void setup(){ Serial.begin(115200); Serial.println("Escaneando bus I2C..."); byte n = 0; Wire.begin(); for (byte i=8; i<120; i++){ Wire.beginTransmission(i); if (Wire.endTransmission() == 0){ Serial.print("Encontre esclavo: "); Serial.println(i); n++; delay(1); } } Serial.println("Fin de busqueda."); Serial.print("Encontre "); Serial.print(n); Serial.println(" esclavo(s)."); } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 5 == Como ya habras sospechado cada dispositivo en el bus I2C debe tener su propia direccion y esta no puede repetirse. Para ello los dispositivos I2C duelen tener un par de pones rotulados C1 y C2, de forma que podemos cambiar la direccion soldando o cortando las pistas, los que permite 4 direcciones distintas. <syntaxhighlight lang="c++"> #include <Wire.h> void setup(){ Wire.begin(); Serial.begin(9600); Serial.println("\nI2C Scanner"); } void loop(){ Serial.println("Escaneando..."); byte error, address, num = 0; for (dir=1; dir<127; dir++ ){ Wire.beginTransmission(dir); error = Wire.endTransmission(); if (error == 0) { Serial.print("Encontré modulo I2C en la dirección 0x"); if (dir < 16){ Serial.print("0"); } Serial.println(dir, HEX); num++; }else if (error == 4){ Serial.print("Error desconocido en dirección 0x"); if (dir < 16){ Serial.print("0"); } Serial.println(dir, HEX); } } if (num == 0){ Serial.println("Ningún modulo I2C se encontró\n"); }else{ Serial.print(num); Serial.println(" módulos encontrados.\n"); } delay(5000); } </syntaxhighlight> == Vea también == <categorytree mode=all>Librerias</categorytree> == Referencias externas == * [https://www.arduino.cc/en/Reference/Wire Wire] * [https://github.com/PaulStoffregen/OneWire OneWire] de Paul Stoffregen * [http://www.gammon.com.au/i2c I2C] - Nick Gammon * [https://aprendiendoarduino.wordpress.com/category/i2c/ Bus I2C] - Enrique Crespo * [https://www.luisllamas.es/arduino-i2c/ El bus I2C en Arduino] - Luis Llamas * [https://github.com/felias-fogg/SoftI2CMaster Soft I2C Master] - otra libreria I2C * [https://programarfacil.com/blog/arduino-blog/conectar-dos-arduinos-i2c/ Conectar 2 Arduino con I2C] - Luis Del Valle * [https://naylampmechatronics.com/blog/35_tutorial-lcd-con-i2c-controla-un-lcd-con-so.html LCD con I2C] - Naylamp * [https://www.prometec.net/combinar-dispositivos-i2c/ Combinar dispositivos I2C] - Prometec [[Category:Librerias]] siae63fc6r2pd0xjgeebrcouibzdo8u 0 28 4284 4202 2019-06-11T23:33:03Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Calcula el valor absoluto de una variable. == Sintaxis == <pre> abs(variable); </pre> == Parámetros == ;variable: variable a avaluar. Tipo numerica: [[char]], [[int]], [[long]] o [[float]]. == Retorno == Retorna el valor absoluto. == Advertencias == Nada. == Ejemplos == <syntaxhighlight lang="c++"> char n = -32; abs(n); //32 </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones matematicas</categorytree> == Referencias externas == [[Category:Funciones matematicas]] nytn1lb9twv64gzc1y2tgwb64v7lhl4 0 188 4478 4241 2019-06-24T22:46:37Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Calcula el arco cuyo coseno es el arco indicado. El arco dado debe estar entre -1 y 1. El resultado sera el angulo en radianes. == Sintaxis == <pre> acos(arco); </pre> == Parámetros == ;arco: numero entre -1 y 1. Numero tipo [[float]]. == Retornos == Angulo en radianes [[float]]. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ for (float n=-1; n<1; n += 0.01){ Serial.print(acos(n)); Serial.print(" radianes, es sexagesimal = "); float x = 360*acos(n)/TWO_PI; Serial.println(x); } } </syntaxhighlight> == Vea también == * [[sin()]] * [[cos()]] * [[tan()]] * [[asin()]] * [[atan()]] * [[PI]] == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones trigonometricas]] pctdt2dokalbht26xi9nw8wf7hnv2i4 0 377 2355 2298 2018-08-09T02:03:22Z Lucario448 3 /* Descripción */ wikitext text/x-wiki == Descripción == El operador de '''ampersand''' <nowiki>(&)</nowiki> se usa para obtener la dirección de memoria (puntero) de una variable individual. El tipo de puntero obtenido es igual al tipo de dato del operando; en caso de que el valor apuntado requiera "reinterpretación" (que no es lo mismo que la conversión explícita o casting), el tipo de puntero debe ser convertido explícitamente. Este truco es útil para directamente leer o modificar cualquier variable como una simple matriz de [[byte|bytes]]. {{Nota|Es incluso válido obtener el puntero de otro puntero, y el de un elemento de una matriz.}} == Sintexis == <pre> variable1 = &variable2; </pre> == Parámetros == ;variable1: ;variable2: == Advertencias == Los punteros son uno de los temas más complicados para los principiantes en el aprendizaje de C, y es posible escribir la gran mayoría de los bocetos de Arduino sin encontrar punteros. Sin embargo, para manipular ciertas estructuras de datos, el uso de punteros puede simplificar el código, y el conocimiento de la manipulación de punteros es útil para tener en el kit de herramientas. == Ejemplo == <pre> byte *p, i=5, resultado; p=&i; //5 resultado = *p; //resultado toma el valor de la posicion de memoria p </pre> == Vea también == * [[asterisco]] - <nowiki>(*)</nowiki> == Referencia == * [https://www.arduino.cc/reference/en/language/structure/pointer-access-operators/reference/ Guia de referencia] [[Category:Estructura]] fyv4fo1f5cqkg30ygjcve9exdk66109 0 31 4866 4765 2019-09-11T22:40:02Z Kike GL 2 /* Advertencias */ wikitext text/x-wiki == Descripción == Lee el valor de pines analógicos marcados en Arduino como A0~A5, con una resolución de 10 bits. Esta instrucción sólo funciona en los pines (A0~A5). {{Tip|Los pines tanto analógicos como digitales de '''entrada''' no necesitan ser definidos con [[pinMode()]].}} == Sintaxis == <pre> analogRead(pin); </pre> == Parámetros == ;pin: un pin analogico. A0~A5 en Arduino [[UNO]] y [[NANO]], A0~A15 en Arduino [[MEGA]]. == Retorno == El rango de valores devuelto puede estar entre 0~1023. Numero tipo [[int]]. == Comentarios == * Si el pin de entrada analógica no está conectado (al aire o flotante), el valor devuelto por '''analogRead()''' fluctuará en base a una serie de factores (por ejemplo, los valores de las otras entradas analógicas, lo cerca que tu mano este a la placa, poner un multimetro en paralelo, etc.). Este fenómeno suele ser aprovechado para el valor de inicialización del generador pseudo-aleatorio de números [[randomSeed()]]. * El rango de entrada y la resolución se pueden cambiar con [[analogReference()]]. * Se tarda unos 100 microsegundos para leer y codificar una entrada analógica, por lo que la velocidad de lectura máxima es de alrededor de 10,000 veces por segundo. * La frecuencia máxima de lectura de un puerto análogo es de 1,5 Mhz (una cada 660 nano segundos). En comparación las entradas digitales pueden llegar a 15 Mhz (una cada 66 nano segundos), leyendo todas las entradas de forma simultánea. {{Tip|Este comando tarda 1775 ciclos de CPU.}} == Advertencias == * No debes dejar al aire estos pines porque generan ruido eléctrico. * La hoja de datos de ATmega también advierte contra el cambio de pines analógicos en proximidad a la realización de lecturas en otros pines analógicos ya que esto puede causar ruido eléctrico e introducir inestabilidad en el sistema analógico. * Puede ser deseable, después de manipular los pines analógicos (en modo digital), agregar un breve retraso antes de usar '''analogRead()''' para leer otros pines analógicos. * La placa Arduino [[UNO]] contiene 6 canales (8 canales para [[MINI]] y [[NANO]], 16 para [[MEGA]]), analógicos con convertidor analógico a digital (ADC) de 10 bit. Esto significa que mapeará tensiones de entrada entre 0~5V en valores enteros entre 0~1023. Esto produce una resolución entre las lecturas de 4.9 mV por unidad. * El comando '''analogRead()''' no funcionará correctamente si un pin analogico se ha configurado previamente como salida con [[pinMode()|pinMode(14, OUTPUT)]], por lo que si este es el caso, configúrelo nuevamente como [[pinMode()|pinMode(14, INPUT)]] antes de usar '''analogRead()'''. De forma similar, si estando como salida se puso [[digitalWrite()|digitalWrite(14, HIGH)]], la resistencia pull-up se establecerá, cuando se vuelva a configurar como entrada con [[pinMode()|pinMode(14, INPUT)]]. * Tenga en cuanta que activar la resistencia pull-up afecta las lecturas de '''analogRead()'''. <pre> pinMode(A0, INPUT_PULLUP); </pre> == Ejemplo 1 == <syntaxhighlight lang="c++"> analogRead(A0); analogRead(5); const byte pin = 3; int valor = analogRead(pin); </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ Serial.println(analogRead(A2)); } </syntaxhighlight> == Ejemplo 3 == En este ejemplo medimos el valor de un sensor cada 15 segundos y promediamos las ultimas 5 lecturas. <syntaxhighlight lang="c++"> const byte ventana = 5; int circularBuffer[ventana]; int* indice = circularBuffer; long suma; byte elementos; float meter(int dato){ suma -= *indice; suma += dato; *indice = dato; indice++; if (indice >= circularBuffer + ventana){ indice = circularBuffer; } if (elementos < ventana){ elementos++; } return (float) suma / elementos; } void setup(){ Serial.begin(115200); } void loop(){ int x = analogRead(A0); Serial.print(x); float media = meter(x); Serial.print(" promedio\t"); Serial.println(media); delay(15000); } </syntaxhighlight> {{Tip|Si prefieres hay una librería llamada [https://github.com/luisllamasbinaburo/Arduino-Meanfilter Arduino Meanfilter] de Luis Llamas que puedes usar.}} == Vea también == <categorytree mode=all>Funciones pines</categorytree> == Referencias externas == * [https://www.arduino.cc/en/Tutorial/AnalogInputPins Guia de referencia Arduino] * [http://manueldelgadocrespo.blogspot.com/p/description-reads-value-from-specified.html Reads value from specified] - Manuel Delgado Crespo * [https://aprendiendoarduino.wordpress.com/tag/analogread/ analogRead()] - Aprendiendo Arduino * [https://www.luisllamas.es/entradas-analogicas-en-arduino/ Entradas analogicas en Arduino] - Luis Llamas * [https://www.luisllamas.es/arduino-filtro-media-movil/ Arduino media movil] - Luis Llamas * [https://www.luisllamas.es/libreria-arduino-mean-filter/ Libreria mean filter] - Luis Llamas * [http://diymakers.es/sensores-en-entradas-analogicas-de-arduino/ Sensores en entradas analogicas de Arduino] - Diy Makers [[Category:Funciones pines]] dllkqlrnor7v6sxaszg7ajwlm4dm42v 0 34 4645 4352 2019-07-04T16:47:50Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Configura el tamaño (en bits) del valor devuelto por [[analogRead()]]. Su valor predeterminado de ADC es 10 bits (devuelve valores entre 0~1023) para la compatibilidad con placas basadas AVR. {{Nota|Extensión de la Analog API para los Arduino [[DUE]] y [[ZERO]].}} El [[DUE]] y el [[ZERO]] tienen capacidades ADC de 12 bits (devuelve valores entre 0~4095) a las que se puede acceder cambiando la resolución a 12. == Sintaxis == <pre> analogReadResolution(bits) </pre> == Parámetros == ;bits: determina la resolución (en bits) del valor devuelto por la función [[analogRead()]]. Puede establecer este entre 1 y 32. Se pueden ajustar resoluciones superiores a 12 pero los valores devueltos por [[analogRead()]] sufrirán una aproximación. == Retornos == Nada. == Advertencias == * Si se establece el valor de analogReadResolution() a un valor más alto que las capacidades de la placa, el Arduino sólo informará en su mayor resolución rellenando los bits extra con ceros. * Por ejemplo: el uso de la Due o la Zero con analogReadResolution(16) le dará un número aproximado de 16 bits con los primeros 12 bits que contienen la lectura ADC real y los últimos 4 bits rellenados con ceros. * Si se establece el valor analogReadResolution() a un valor inferior a las capacidades de la placa, se descartarán los bits menos significativos adicionales leídos de la ADC. * El uso de una resolución de 16 bits (o cualquier resolución mayor que las capacidades reales del hardware) le permite escribir sketchs que manejan automáticamente los dispositivos con una resolución ADC mayor cuando éstos estén disponibles en las placas futuras sin cambiar una sola línea de código. == Ejemplo == <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); } void loop() { //Lee la entrada A0 con resolución por defecto (10 bits) analogReadResolution(10); Serial.print("ADC 10 bit (default) : "); Serial.print(analogRead(A0)); //Cambia la resolución a 12 bits y lee A0 analogReadResolution(12); Serial.print(", 12 bit : "); Serial.print(analogRead(A0)); //Cambia la resolución a 16 bits y lee A0 analogReadResolution(16); Serial.print(", 16 bit : "); Serial.print(analogRead(A0)); //Cambia la resolución a 8 bits y lee A0 analogReadResolution(8); Serial.print(", 8 bit : "); Serial.println(analogRead(A0)); delay(100); } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones pines</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [http://manueldelgadocrespo.blogspot.com/p/analogreadresolution.html analogReadResolution()] - Manuel Delgado [[Category:Funciones pines]] hpz7l4xnzv5ornj39622l5l98odak2o 0 36 4350 4349 2019-06-12T22:38:09Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Configura la tensión de referencia usada para las entradas analógicas (por ejemplo, el valor usado como la parte superior del rango de entrada). Las opciones son: ;DEFAULT: la referencia analógica por defecto, 5V (en placas Arduino alimentadas a 5V) o 3V3 (en placas Arduino alimentadas a 3V3) ;INTERNAL: una referencia incorporada, igual a 1V1 en el ATmega168 o ATmega328 y 2V56 en el ATmega8 (no disponible en el Arduino [[MEGA]]) ;INTERNAL1V1: una referencia incorporada de 1.1V (solo Arduino [[MEGA]]) ;INTERNAL2V56: una referencia incorporada de 2.56V (solo Arduino [[MEGA]]) ;EXTERNAL: la tensión aplicada al pin AREF (solo de 0~5V) se usa como referencia. {{Nota|Después de cambiar la referencia analógica, las primeras lecturas de '''analogRead()''' puede que no sean exactas.}} == Sintaxis == <pre> analogReference(type); </pre> == Parámetros == ;type: el tipo de referencia a usar (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56 o EXTERNAL). == Retornos == Nada. == Comentarios == == Advertencias == * No use cualquier tensión menor de 0V o mayor de 5V como tensión de referencia externa en el pin AREF. * Si está usando una referencia externa en el pin AREF, debe establecer la referencia analógica a EXTERNAL antes de llamar [[analogRead()]]. De lo contrario, se produce un cortocircuito entre la tensión de referencia interna (generada internamente) y la tensión aplicada al pin AREF, dañando posiblemente el uC de la placa Arduino. * Como alternativa, puede conectar la tensión de referencia externa al pin AREF a través de una resistencia de 5K, que le permite cambiar entre las tensiones de referencia externa e internas. Tenga en cuenta que la resistencia va a alterar la tensión que se usa como referencia porque hay una resistencia interna de 32 K en el pin AREF. Las dos actúan como un divisor de tensión, por lo que, por ejemplo, 2V5 aplicados a través de la resistencia producirá 2.5 * 32 / (32 + 5) = ~ 2V2 en el pin AREF. == Ejemplo == <pre> </pre> == Vea también == <categorytree mode=all>Funciones pines</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [https://www.insidegadgets.com/2011/11/05/modifying-the-standalone-temperature-logger-to-log-voltage/ Modifying the standalone temperature logger to log voltage] * [http://manueldelgadocrespo.blogspot.com/p/description-configures-reference.html analogReference()] - Manuel Delgado * [http://platea.pntic.mec.es/~lmarti2/arduino/pract3/analogreference.htm analogReference()] - Intef * [https://aprendiendoarduino.wordpress.com/tag/aref/ AREF] - Enrique Crespo * [https://www.prometec.net/aref/ AREF] - Prometec * [http://panamahitek.com/pin-aref-en-arduino/ AREF] - Panama Hitek [[Category:Funciones pines]] 7iz1l77mwax2v0hov3uk745u4tfsiju 0 33 5114 5054 2019-12-17T00:29:31Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Escribe un valor en un pin analógico (genera onda PWM). Se puede usar para encender un LED con luminosidad variable o accionar un motor que soporte PWM a diferentes velocidades. Después de llamar a '''analogWrite()''', el pin va a generar una onda cuadrada constante del ciclo de trabajo especificado hasta la siguiente llamada a '''analogWrite()''' o una llamada a [[digitalRead()]] o [[digitalWrite()]] en el mismo pin. {{Tip|No es necesario llamar a [[pinMode()]] para configurar el pin como salida antes de llamar analogWrite().}} == Sintaxis == <pre> analogWrite(pin, PWM); </pre> == Parámetros == ;pin: pin a usar. En Arduino [[UNO]] son: 3, 5, 6, 9, 10 y 11. ;PWM: ciclo de trabajo: entre 0 (siempre apagado) y 255 (siempre encendido). {{Tip|Te recomiendo usar [[map()]] para adecuar los valores desde un pin analogico.}} == Retornos == Nada. == Comentarios == * La frecuencia de la señal PWM en la mayoría de los pines es de aproximadamente 490 Hz. * En Arduino [[UNO]] y similares, los pines 5 y 6 tienen una frecuencia de aproximadamente 980 Hz. * En Arduino [[Leonardo]] los pines 3 y 11 también se ejecutan a 980 Hz. {{Nota|La función analogWrite() no tiene nada que ver con los pines analógicos o la función [[analogRead()]].}} {{Tip|Este comando tarda 129 ciclos de CPU.}} == Advertencias == * En la mayoría de las placas Arduino (con uC ATmega168 o ATmega328), esta función se puede utilizar en los pines 3, 5, 6, 9, 10, y 11. * En el Arduino [[MEGA]], funciona en los pines 2 a 13 y 44 a 46. * Las placas Arduino más antiguas con uC ATmega8 sólo admiten analogWrite() en los pines 9, 10 y 11. * En el Arduino [[DUO]] analogWrite() funciona en los pines 2 a 13, más en los pines DAC0 y DAC1. A diferencia de los pines PWM, DAC0 y DAC1 son convertidores Digitales a Analógicos, y actúan como verdaderas salidas analógicas. * Las salidas PWM generadas en los pines 5 y 6 tendrán ciclos de trabajo más altos de lo esperado. Esto es debido a las interacciones con las funciones [[millis()]] y [[delay()]], que comparten el mismo temporizador interno usado para generar las salidas PWM. Esto se notará sobre todo en entornos de pequeño ciclo de trabajo (por ejemplo 0 - 10) y puede dar lugar a que un valor de 0 apague completamente la salida en los pines 5 y 6. == Ejemplo 1 == <syntaxhighlight lang="c++"> byte n; void setup(){ pinMode(10, OUTPUT); } void loop(){ analogWrite(10, n); n++; delay(10); } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> const byte led = 9; //LED PWM const byte pot = A3; //potenciómetro void setup() { pinMode(led, OUTPUT); pinMode(pot, INPUT); //En realidad no es necesario } void loop() { int val = analogRead(pot); //lee el pin de entrada (genera valores enteros entre 0~1023) analogWrite(led, val/4); //PWM, soporta valores enteros entre 0~255 } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones pines</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/analog-io/analogread/ Guia de referencia de Arduino] * [https://www.luisllamas.es/tag/pwm/ PWM] - Luis Llamas * [https://www.youtube.com/watch?v=RdfVdgkv51E Manejo de Servomotores con Arduino] - Humberto Higinio * [https://www.youtube.com/watch?v=GnlmVMHA_wQ Que es PWM y para que sirve] - Rincon Ingenieril * [https://programarfacil.com/podcast/26-arduino-entradas-y-salidas/ Entradas y salidas] - Luis del Valle * [https://www.luisllamas.es/salidas-analogicas-pwm-en-arduino/ Salidas analogicas en Arduino] - Luis Llamas * [http://manueldelgadocrespo.blogspot.com/p/analogwrite.html analogWrite()] - Manuel Delgado * [http://diymakers.es/pwm/ PWM] - Diy Makers * [http://diymakers.es/mover-motores-paso-paso-con-arduino/ Motor paso a paso con arduino] - Diy Makers * [http://diymakers.es/control-velocidad-y-sentido-de-motor-dc/ Control de velocidad y sentido de motor DC] - Diy Makers [[Category:Funciones pines]] hn9p0q0i99gzs8jyieux5agqvjmn0jt 0 35 4646 4353 2019-07-04T16:48:54Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Configura la resolución de la función [[analogWrite()]]. Esta resolución es, por defecto, de 8 bits (valores entre 0~255) para compatibilidad con las placas basadas en AVR. {{Nota|analogWriteResolution() es una extensión de Analog API para los Arduino Due y Zero.}} == Sintaxis == <pre> analogWriteResolution(bits); </pre> == Parámetros == ;bits: determina la resolución (en bits) de los valores utilizados en la función [[analogWrite()]]. El valor puede oscilar entre 1~32. Si se selecciona una resolución más alta o más baja que las capacidades del hardware de la placa, el valor utilizado en [[analogWrite()]] será truncado si es demasiado alto o rellenado con ceros si es demasiado bajo. Véase la nota a continuación para más detalles. == Retornos == Nada. == Advertencias == * El Due tiene las siguientes capacidades de hardware: ** 12 pines que, por defecto, son PWM de 8-bit, al igual que las placas basadas en AVR. Esta resolución se puede cambia a 12-bit . ** 2 pins con DAC (Conversor Digital a Analógico) de 12 bit. Cambiando la resolución de escritura a 12, se puede utilizar [[analogWrite()]] con valores entre 0 y 4095 para explotar la resolución completa del DAC o para ajustar la señal de PWM sin darse la vuelta (rolling over). * El Zero tiene las siguientes capacidades hardware: ** 10 pines que, por defecto, son PWM de 8-bit, igual que las placas basadas en AVR. Esta resolución se puede cambiar a 12-bit. ** 1 pin conDAC (Convertidor Digital a Analógico) de 10-bit . Cambiando la resolución de escritura a 10, se puede utilizar [[analogWrite()]] con valores entre 0 y 1023 para explotar la resolución completa del DAC. == Ejemplo == <pre> void setup(){ // abre la conexión serie Serial.begin(9600); // configura los pines digitales como salidas pinMode(11, OUTPUT); pinMode(12, OUTPUT); pinMode(13, OUTPUT); } void loop(){ //lee la entrada A0 y la mapea al pin PWM int sensorVal = analogRead(A0); Serial.print("Analog Read : "); Serial.print(sensorVal); //Resolución PWM por defecto analogWriteResolution(8); analogWrite(11, map(sensorVal, 0, 1023, 0 ,255)); Serial.print(" , valor PWM de 8 bit: "); Serial.print(map(sensorVal, 0, 1023, 0 ,255)); //Cambia la resolución PWM a 12 bits (solo DUE) analogWriteResolution(12); analogWrite(12, map(sensorVal, 0, 1023, 0, 4095)); Serial.print(" , 12-bit PWM value : "); Serial.print(map(sensorVal, 0, 1023, 0, 4095)); //Cambia la resolución PWM a 4 bits analogWriteResolution(4); analogWrite(13, map(sensorVal, 0, 1023, 0, 127)); Serial.print(", 4-bit PWM value : "); Serial.println(map(sensorVal, 0, 1023, 0, 127)); delay(5); } </pre> == Vea también == <categorytree mode=all>Funciones pines</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/analogwriteresolaution/ Guia de referencia de Arduino] * [http://manueldelgadocrespo.blogspot.com/p/analogwriteresolaution.html analogWriteResolution()] - Manuel Delgado [[Category:Funciones pines]] qkx389f84q4bzyrtjmn52rhxfeqtj0p 0 97 5296 5292 2020-06-06T21:40:03Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Operador lógico que hace las veces de conectiva conjuntiva ("y"), cuyo resultado es dado por la siguiente tabla de verdad: {| class="wikitable col3cen" !a!!b!!a <nowiki>&&</nowiki> b |- |0||0||0 |- |1||0||0 |- |0||1||0 |- |1||1||1 |} == Sintaxis == <pre> expresion 1 && expresion 2; expresion 1 and expresion 2; </pre> == Retorna == Verdadero o falso. == Advertencias == * No confundir el operador boleano '''and''' (<nowiki>&&</nowiki>), con el operador [[and bit a bit]] (<nowiki>&</nowiki>). * Solo si todos los términos son verdaderos al expresión es verdadera. == Ejemplo == <syntaxhighlight lang="c++"> if (x > 9 && x < 20){ //Esta entre 10 y 19 }else{ //Esta fuera del rango } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador logico</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [https://programarfacil.com/blog/programacion/la-logica-en-la-programacion/ La lógica en la programacion] - Luis Del Valle * [https://aprendiendoarduino.wordpress.com/category/operadores/ Operadores] - Aprendiendo Arduino [[Category:Operador logico]] 9ul4mensqd8damfixn3iwe8owdqav6g 0 207 4987 4706 2019-09-26T23:27:35Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == El operador binario bit a bit AND es representado por el caracter et (ampersand) '''&'''. AND establece (pone en 1) un bit sí y solo si el bit de esa posición está establecido (en 1) en ambos operandos. {| class="wikitable col1cen col2cen col3cen" !a!!b!!a <nowiki>&</nowiki> b |- |0||0||0 |- |1||0||0 |- |0||1||0 |- |1||1||1 |} {{Nota|esta operación también es utilizada para borrar (poner en cero) uno o varios bits específicos en una variable. Todo bit en 1 en el segundo operando, se quedará como está; mientras que todo bit en cero se borrará}} == Sintaxis == <pre> op1 & op2 </pre> ;op1: primer operando, es la variable (de cualquier tipo) a modificar. ;op2: segundo operando, es quien va a relizar las modificaciones pertinentes. == Retorno == El valor resultante, donde cada bit se establece sólo si lo está en ambos operandos. == Advertencias == * No confundir el '''operador bit a bit and''' (&) con el boleano [[and]] ('''<nowiki>&&</nowiki>'''). * Idealmente ambos operandos deberían ser del mismo tipo (tamaño); en caso de no ser así, solo se operará con los bytes menos significativos del segundo, o se podrían borrar bits si este es el más pequeño. == Ejemplo == <syntaxhighlight lang="c++"> char n = -64; n &= B01111111; //Con esto lo acabo de convertir en positivo; mientras que los demás bits no me interesan, por eso no los toco. </syntaxhighlight> == Vea también == <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Operador logico</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [https://playground.arduino.cc/Code/BitMath/#bitwise_and Bitwise AND] - Playground [[Category:Operador bit a bit]] n3garx4txy4p3edylnj4m18mpmsp528 0 375 5023 5022 2019-09-27T00:09:27Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == El operador '''and bit a bit compuesto''' <nowiki>(&=)</nowiki> se usa a menudo para forzar determinados bits en una variable a 0 (LOW). {| class="wikitable col3cen" !a!!b!!a <nowiki>&=</nowiki> b |- |0||0||0 |- |1||0||0 |- |0||1||0 |- |1||1||1 |} {{Nota|A menudo se hace referencia en las guías de programación como "borrado" o "reseteado" (RESET) de bits.}} == Sintaxis == <pre> variable &= mascara; variable = variable & mascara; </pre> == Parámetros == ;variable: Nombre de ala variable sobre la cual operar. ;mascara: Constante entera puede ser [[char]], [[byte]], [[int]], [[long]]. == Retorno == * Los bits tratados con 0 se fuerzan a 0, sin importar su estado. * Los bits tratados con 1 mantienen su estado. == Comentarios == debido a que se trata de bits de un operador de bits - es conveniente usar el formateador binario con constantes. Las cifras siguen siendo el mismo valor en otras representaciones, que simplemente no son tan fáciles de entender. Además, B00000000 se muestra por claridad, pero cero en cualquier formato de número es cero. == Advertencias == Nada. == Ejemplo == Para configurar los bits 0 (menos significativo) y 0 de una variable, dejando el resto de la variable sin cambios, se use el operador '''and bit a bit compuesto''' (&=) con la constante B11111100. <syntaxhighlight lang="c++"> byte a = B10101010; a |= B11111100; //B10101000 </syntaxhighlight> {|class="wikitable" |Variable||Bxxxxxxxx |- |Mascara||B11111100 |- |Resultado||Bxxxxxx00 |} == Vea también == <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Operador bit a bit compuesto</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias externas == * [https://manueldelgadocrespo.blogspot.com/p/blog-page_14.html Manuel Delgado crespo] [[Category:Operador bit a bit compuesto]] h8tgwo4ey0hzkwj4n2zsbaq3c403cly 0 90 5026 5025 2019-09-27T00:14:01Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Almacena el valor de la derecha del signo igual en la variable de la izquierda del signo igual. Un solo signo de igualdad, en el programación Arduino, se llama '''operador de asignación'''. Tiene un significado diferente del que tiene en álgebra, donde indica una ecuación o igualdad. El operador de asignación indica al uC que avalúe cualquier valor o expresión que esté a la derecha del signo igual y que lo almacene en la variable. == Sintaxis == <pre> tipo variable = valor; tipo variable = expresion; </pre> == Parámetros == ;tipo: determina el tipo de variable: [[bool]], [[char]], [[byte]], [[int]], [[long]], [[float]], etc ;variable: nombre de variable a definir. ;valor: un valor a asignar a la variable, ;expresion: expresión o formula que determinara el valor de la variable. == Advertencias == * La variable del lado izquierdo del operador de asignación (signo =) tiene que tener capacidad para almacenar el valor. Si no es lo suficientemente grande para contener el valor, el valor almacenado en la variable será incorrecto. * No se debe confundir el operador de asignación '''=''' (un solo signo igual) con el operador de comparación '''==''' (dos signos igual), que avalúa si dos expresiones son iguales. == Ejemplos == <syntaxhighlight lang="c++"> bool a = false; byte n = 122; int x = 1024; char c = 'a'; int z = analogRead(A0); </syntaxhighlight> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Operador aritmetico]] 4ytnp4z3ecv225z3ron712e4sipwean 0 187 4479 4477 2019-06-24T22:47:33Z Kike GL 2 /* Advertencias */ wikitext text/x-wiki == Descripción == Calcula el arco cuyo seno es el arco indicado. El arco dado debe estar entre -1 y 1. El resultado sera el angulo en radianes. == Sintaxis == <pre> asin(arco); </pre> == Parámetros == ;arco: numero entre -1 y 1. Numero tipo [[float]]. == Retornos == Angulo en radianes [[float]]. == Advertencias == El arco debe ser entre -1 y +1. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ for (float n=-1; n<1; n += 0.01){ Serial.print(asin(n)); Serial.print(" radianes, es sexagesimal = "); float x = 360*asin(n)/TWO_PI; Serial.println(x); } } </syntaxhighlight> == Vea también == * [[sin()]] * [[cos()]] * [[tan()]] * [[acos()]] * [[atan()]] * [[PI]] == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones trigonometricas]] 4ejduf65rhzddcysuo8ong2mwa1xewc 0 378 5236 5040 2020-02-02T18:54:04Z Kike GL 2 /* Ejemplo 2 */ wikitext text/x-wiki == Descripción == El operador de '''asterisco''' <nowiki>(*)</nowiki> tiene dos funciones: # Declarar variables como punteros de cierto tipo de dato. # Desreferenciar; dicho en otras palabras, trabajar con el valor apuntado en vez del puntero en sí. Dicho valor dependerá del tipo de dato del puntero (es "interpretado" segun la posición de memoria dada). {{Nota|A menos que el microcontrolador tenga más de 32 KB de [[SRAM]], los punteros siempre serán variables enteras de 16 bits (el equivalente a [[word]]) independientemente del tipo que interpreten. De hecho también se pueden realizar las típicas operaciones matemáticas en punteros como cualquier otro tipo número-entero de variable conocido.}} == Sintaxis == Declara un puntero. La diferencia con la declaracion de una variable normal radica en el * después del tipo de dato y antes del nombre. <pre> tipo* puntero; </pre> Asigne el valor apuntado por variable2. Cuando no es en una declaración, se usa para desreferenciar. El * va antes del nombre del puntero. <pre> variable1 = *variable2; </pre> == Parámetros == ;puntero: Una variable que se utiliza como puntero, y que la posición apuntada será interpretada como si fuera un dato de tipo '''tipo'''. ;variable1: Una variable normal (que solamente almacena un dato del tipo declarado). ;<nowiki>*</nowiki>variable2: Puntero del cuál se quiere obtener el valor de la posición a la que apunta. == Comentarios == Los punteros son uno de los temas más complicados para los principiantes de Arduino y es posible escribir la gran mayoría de [[boceto]]s sin tener que encontrarse con los punteros. Sin embargo, para la manipulación de ciertas estructuras de datos, el uso de punteros puede simplificar el código, y el conocimiento de la manipulación de punteros es útil para tener en la propia caja de herramientas. Bien usados, los punteros son excepcionalmente útiles para resolver cierto tipo de problemas, pero aprender a manejarlos puede provocar serios dolores de cabeza, especialmente cuando tratas de depurar un programa que se niega a funcionar como debe. En primer lugar debemos entender que la memoria del Arduino está numerada en posiciones. Cada posición de memoria tiene una dirección única, que debe ser especificada cuando queremos leer o escribir su valor. Si miramos el tipo de memoria de los distintos Arduinos, vemos que, por ejemplo, el [[UNO]] dispone de 32 K de memoria [[flash]] para almacenamiento de programas y de 2 K de [[SRAM]] para almacenar de variables. Cuando definimos una variable en el [[boceto]], el compilador le asigna una posición en la memoria [[SRAM]]. Si la variables es del tipo [[char]] o [[byte]] asigna un byte de memoria, si es del tipo [[int]] o [[unsigned int]] le asigna dos posiciones de memoria y si es un tipo [[long]] o [[unsigned long]] le asigna 4 posiciones de memoria. <pre> int numero; //Declaramos variable numero = 123; //Definimos variable </pre> {|class="wikitable" !Nombre!!Dirección de memoria!!Contenido |- |numero||2050||123 |} Esto nos da una idea de lo que puede suceder si escribimos un valor long en una dirección de memoria que corresponde a un int. Como el tipo long ocupa 4 bytes, cuando intentemos meterlos en una dirección a la que se ha asignado 2 bytes, va a ocupar el contenido de las siguientes posiciones de memoria, que pueden estar usadas por otros satos. Prueba esto: <pre> void setup(){ Serial.begin(115200); int numero; long n = 100000; numero = n; //Estas intentando guardar 4 byte donde solo reservaste 2 bytes Serial.println(numero); //-31072 } void loop(){ //Nada } </pre> Cuando declaras una matriz, en realidad estás declarando un puntero. De hecho es posible utilizar '''[]''' en cualquier puntero, aunque este no se haya declarado explícitamente como una matriz.<br> La diferencia entre declarar un puntero y una matriz, está en lo que ocurre implícitamente: declarar un puntero es igual que declarar cualquier otra variable simple; mientras que declarar una matriz es más que asignar 2 bytes, es asignar otro espacio según el tipo de dato y el número ingresado entre los '''[]''' (o en su defecto, la cantidad de elementos que aparece entre los '''{}'''), inicializarlo con ceros o con los valores preestablecidos, y finalmente asignarle al respectivo puntero la posición del primer byte de ese espacio que tuvo que asignar. El acceso a un elemento es más amigable hacerlo con los '''[]''', sin embargo existen dos formas de realizar la misma acción: <pre> matriz[i] = 4; *(matriz + i) = 4; // Ambos hacen exactamente lo mismo </pre> De las dos formas es válido ya que una matriz es un puntero, y en cierto modo también se puede decir que al revés. == Advertencias == * Errores de '''overflow''' de registro no son advertidos por el compilador, ya que el puntero puede apuntar en cualquier posición arbitraria de la memoria. Tanto así que puede apuntarse a sí mismo, a otro puntero, e incluso a cualquier variable, matriz u objeto existente en el momento. * '''Un gran poder conlleva una gran responsabilidad'''. Debido a que el puntero tiene el "superpoder" de meterse en cualquier parte de la memoria de ejecución ([[SRAM]]), existe el riesgo de corromperla sin previo aviso y colgar el programa en cuestión. == Ejemplo 1 == <syntaxhighlight lang="c++"> byte *p; i=5, resultado; p = &i; //5 resultado = *p; //resultado toma el valor de la posicion de memoria de p </syntaxhighlight> == Ejemplo 2 == Implementamos un '''buffer circular''' con puntero. <syntaxhighlight lang="c++"> const int ventana = 5; int circularBuffer[ventana]; int* indice = circularBuffer; void meter(int valor){ *indice = valor; indice++; if (indice >= circularBuffer + ventana){ indice = circularBuffer; } } void setup(){ Serial.begin(115200); } void loop(){ if (Serial.available()){ int x = Serial.parseInt(); meter(x); for (byte n=0; n<ventana; n++){ Serial.print(circularBuffer[n]); Serial.print(","); } Serial.println(); } } </syntaxhighlight> == Ejemplo 3 == No se puede crear una [[matriz]] de matrices. Pero si se puede usar '''punteros''' a matrices, asi: <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); byte cero[] = { 0xA6, 0xD4, 0xAC, 0xF8 }; byte uno[] = { 0xE9, 0x48, 0xCC, 0xE3 }; byte dos[] = { 0x46, 0x6F, 0xA5, 0xF8 }; byte tres[] = { 0xC2, 0x9D, 0xFC, 0x33 }; byte* matriz[4] = {cero, uno, dos, tres}; //Usando puntero for (byte i=0; i<4; i++){ for (byte j=0; j<4; j++){ Serial.print(matriz[i][j], HEX); Serial.print(", "); } Serial.println(); } } void loop() { //Nada } </syntaxhighlight> == Vea también == * [[ampersan]] - <nowiki>(&)</nowiki> == Referencias == * [https://www.arduino.cc/reference/en/language/structure/pointer-access-operators/dereference/ Guia de referencia] * [https://www.luisllamas.es/buffer-circular-arduino/ Buffer circular en Arduino] - Luis LLamas * [https://www.prometec.net/punteros/ Punteros] - Prometec * [http://diwo.bq.com/arduino-variables-punteros/ Punteros] - Diwo * [http://panamahitek.com/punteros-serial-arduino-parte-iii/ Punteros Arduino] - Panama Hitek [[Category:Estructura]] odbvb7txjngg98kdf3ytdg1a5jm5jn4 0 189 4193 2728 2019-06-11T21:14:02Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Calcula el arco cuyo tangente es el arco indicado. == Sintaxis == <pre> atan(arco); </pre> == Parámetros == ;arco: cualquier numero. Numero tipo [[float]]. == Retornos == Angulo en radianes [[float]]. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ for (float n=-100; n<100; n++){ Serial.print(atan(n)); Serial.print(" radianes, es sexagesimal = "); float x = 360*atan(n)/TWO_PI; Serial.println(x); } } </syntaxhighlight> == Vea también == * [[sin()]] * [[cos()]] * [[tan()]] * [[asin()]] * [[acos()]] * [[PI]] == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones trigonometricas]] 2siniekwrdsf3plsfuewlee54pm0ykk 0 365 4504 4496 2019-06-24T23:05:42Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Convertir una matriz [[char]] o [[string]] a [[float]]. {{Tip|Ojo desde una matriz a [[float]].}} == Sintaxis == <pre> atof(matriz); </pre> == Parametros == ;matriz: nombre de la matriz tipo [[char]] == Retorno == Numero tipo [[float]]. == Advertencias == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); char texto[] = "-123.45"; float x = atof(texto); Serial.println(x, 3); //-123.450 } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> == Referencias == * [https://www.luisllamas.es/convertir-texto-a-numero-arduino/ Convertir texto a numero] - Luis Llamas [[Category:Funciones conversion]] 2zr7elsfjjc1wo2ihz38n63e588ahj8 0 402 4497 4494 2019-06-24T22:58:34Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == Convertir una matriz [[char]] o [[string]] a [[int]]. {{Tip|Ojo desde una matriz a [[int]].}} == Sintaxis == <pre> atoi(matriz); </pre> == Parametros == ;matriz: nombre de la matriz tipo [[char]] == Retorno == Numero tipo [[int]]. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); char texto[] = "-12345"; int x = atoi(texto); x += 12300; Serial.println(x); //-45 } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> == Referencias == * [https://www.luisllamas.es/convertir-texto-a-numero-arduino/ Luis LLamas] [[Category:Funciones conversion]] 3jx8buk7kq9l3m64hxm97qbkq2c05ij 0 364 4505 4493 2019-06-24T23:06:01Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Converir una matriz [[char]] o [[string]] en [[long]]. {{Tip|Ojo desde una matriz a [[long]].}} == Sintaxis == <pre> atol(matriz); </pre> == Parametros == ;matriz: nombre de la matriz tipo [[char]] == Retorno == Numero tipo [[long]]. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); char texto[] = "-12345"; Serial.println(atol(texto)/5); //-2469 } void loop(){ //Nada } </syntaxhighlight> == Vea también == * [[string]] * [[atoi()]] * [[strtoul()]] * [[atof()]] * [[strlen()]] == Referencias == * [https://www.luisllamas.es/convertir-texto-a-numero-arduino/ Convertir texto a numero] - Luis Llamas [[Category:Funciones conversion]] 1qknrfziy0wxdbluar619xsucjh4ytu 0 40 5047 5046 2019-10-07T21:56:32Z Kike GL 2 /* Advertencias */ wikitext text/x-wiki == Descripción == Esta función no permite traducir el pin digital real al número de interrupción específico. Normalmente, debe usar digitalPinToInterrupt(pin), en lugar de colocar un número de interrupción directamente en su boceto. Los pines específicos con interrupciones, y su asignación para interrumpir el número varía en cada tipo de placa. El uso directo de números de interrupción puede parecer simple, pero puede causar problemas de compatibilidad cuando el boceto se ejecuta en una placa diferente. Sin embargo, los bocetos más antiguos a menudo tienen números de interrupción directa. A menudo se usaron el número 0 (para el pin digital 2) o el número 1 (para el pin digital 3). La tabla a continuación muestra los pines de interrupción disponibles en varios tableros. Tenga en cuenta que en la tabla a continuación, los números de interrupción se refieren al número que se pasará a attachInterrupt(). Por razones históricas, esta numeración no siempre se corresponde directamente con la numeración de interrupción en el chip ATmega (por ejemplo, int.0 corresponde a INT4 en el chip ATmega2560). Pines digitales con Interrupción. {| class="wikitable col2cen col3cen col4cen col5cen col6cen" |+Pines de interrupcion en Arduino !Arduino!!INT.0!!INT.1!!INT.2!!INT.3!!INT.4!!INT.5 |- |[[UNO]]||2||3||&nbsp;||&nbsp;||&nbsp;||&nbsp; |- |[[MEGA]]||2||3||21||20||19||18 |- |32u4||3||2||0||1||7||&nbsp; |- |[[DUO]]||colspan=6|Todos los pines |} {{Tip|Asi como hay las INT tambien hay las PCINT (Ping Change INT). No son tan versatiles, son mas lentas pero son muchas.}} == Sintaxis == <pre> attachInterrupt(digitalPinToInterrupt(pin), ISR, mode); //recomendado attachInterrupt(INT, ISR, modo); //no recomendado attachInterrupt(pin, ISR, modo) ; //Solo DUE, Zero y MKR1000. </pre> == Parámetros == El primer parámetro para '''attachInterrupt()''' es el número de interrupción. Normalmente debería utilizar digitalPinToInterrupt(pin) para traducir el pin digital real al número de interrupción específica. Por ejemplo, si se conecta al pin3, utilice digitalPinToInterrupt(3) como el primer parámetro para '''attachInterrupt()'''. ;INT: Es el número de interrupción (int) ;pin: Es el número de pin (solo [[DUE]], [[Zero]], [[MKR1000]]) ;ISR: Función de usuario que se invoca cuando sucede la interrupción; esta función no debe tener parámetros ni devolver nada. Esta función a veces se denomina Rutina del Servicio de Interrupciones. ;modo: define cuando debe ser disparada la interrupción. Existen cuatro constantes predefinidas como valores válidos :LOW dispara la interruoción cuando el pin está a nivel bajo. :CHANGE dispara la interrupción cuando el pin cambia su valor. :RISING dispara la interrupción cuando el pin pasa de nivel bajo a nivel alto. :FALLING dispara la interrupción cuando el pin pasa de nivel alto a nivel bajo. == Retornos == Nada. == Comentarios == * Haz lo que quieras pero no te demores. Acaba cuanto antes y lárgate. Debes entender que una interrupción es como un estado de excepción, que se puede usar sin reparos, pero entendiendo que hay que hacer el trabajo y salir cuanto antes. * Hay cosas que no funcionan, como las funciones: [[delay()]], [[millis()]], Serial.xx y cualquier cosa que dependa de interrupciones o timers. * De hecho, una ISR o función CallBack, no puede retornar parámetros ni tampoco recibirlos. == Advertencias == * Dentro de la función de Interrupción, [[delay()]] no funcionará y el valor devuelto por [[millis()]] no aumentará. Los datos serie recibidos, mientras que la función está activa se pueden perder. Usted debe declarar como [[volatile]] cualquier variable que se modifique dentro de la función de Interrupción. Vea la sección de ISR a continuación para obtener más información. == Ejemplo 1 == En este ejemplo hacemos que el LED a bordo conmute con un pulsador en el pin digital 2. <syntaxhighlight lang="c++"> const byte pulsador = 2; volatile bool estado = LOW; //Sinonimo de false o 0. void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(pulsador, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(pulsador), cambia, CHANGE); } void cambia(){ estado = !estado; } void loop(){ digitalWrite(LED_BUILTIN, estado); } </syntaxhighlight> == Ejemplo 2 == En este ejemplo hacemos que el LED a bordo conmute con un pulsador en el pin digital 2 considerando el [[Rebote]] <syntaxhighlight lang="c++"> const byte pulsador = 2; const byte retardo = 150; volatile bool estado = LOW; //Sinonimo de false o 0. volatile unsigned long tiempo = 0; volatile byte n = 0; volatile byte anterior = 0; void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(pulsador, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(pulsador), cambia, FALLING); } void cambia(){ if (millis() > tiempo + retardo){ estado = !estado; tiempo = millis(); n++; } } void loop(){ if (n != anterior){ digitalWrite(LED_BUILTIN, estado); anterior = n; Serial.println(n); } } </syntaxhighlight> == Vea también == * [[detachInterrupt()]] * [[interrupts()]] * [[noInterrupts()]] * [[digitalPinToInterrupt()]] * [[PCINT]] == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [http://www.gammon.com.au/interrupts Interrupts] - Nick Gammon * [https://www.luisllamas.es/tag/interrupciones/ Interrupciones (INT)] - Luis Llamas * [https://www.luisllamas.es/interrupciones-en-todos-los-pines-de-arduino-con-pcint/ Arduino PCINT] - Luis Llamas [[Category:Funciones interrupciones]] hp28xtldh1xm1mbvsg1rwbaczmz3fmh 0 45 4780 4779 2019-07-17T22:29:22Z Kike GL 2 /* Ejemplo 3 */ wikitext text/x-wiki == Descripción == Calcula el valor del bit especificado por el parámetro. {| class="wikitable" |- | bit || 0 || 1 || 2 || 3 || 4 || 5 || 6 || 7 |- | valor || 1 || 2 || 4 || 8 || 16 || 32 || 64 || 128 |} == Sintaxis == <pre> bit(valor); bit(variable); </pre> == Parámetros == ;valor: valor a evaluar. ;variable: variable a evaluar. == Retornos == Retorna el bit 2^valor o 2^variable. == Advertencias == Nada. == Ejemplos 1 == <syntaxhighlight lang="c++"> bit(2); //4 bit(5); //32 bit(8); //256 </syntaxhighlight> == Ejemplos 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); for (byte i=0; i<10; i++){ Serial.println(bit(i)); } } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 3 == Parpadea el LED a bordo. <syntaxhighlight lang="c++"> void setup() { DDRB = DDRB | bit(5); //Configura el pin digital 13 (bit 5) como OUTPUT, no altera el resto. } void loop() { PORTB = PORTB ^ bit(5); //Invertir estado del pin digital 13 (bit 5), no altera el resto. delay(500); } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones bit y byte</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones bit y byte]] 9rb7khkzrpil7db6zk7a1kc9r5vpdnv 0 191 4783 4782 2019-07-17T23:36:53Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Borra (pone a 0) un bit de una variable numérica. == Sintaxis == <pre> bitClear(variable, n) </pre> == Parámetros == ;variable: variable a evaluar. ;n: bit a borrar. Desde 0 el bit menos significativo (mas a la derecha). == Retornos == Nada. == Advertencias == Ninguna. == Ejemplo 1 == <syntaxhighlight lang="c++"> byte pinState = B00000000; //Inicializa todos los pines en LOW bitClear(pinState, 2); //Poner el 3er bit LOW ose B0000100 </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> byte pinState = B11111111; //Inicializa todos los pines en HIGH bitClear(pinState, 2); //Poner el 3er bit LOW ose B11111011 </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones bit y byte</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [http://manueldelgadocrespo.blogspot.com/p/bitclear.html bitClear()] de Manuel delgado [[Category:Funciones bit y byte]] ey5ku2d9s1zd461776pjp9v0ix5jgkm 0 192 4791 4790 2019-07-17T23:53:15Z Kike GL 2 /* Ejemplo 4 */ wikitext text/x-wiki == Descripción == Lee un bit especifico de una variable. == Sintaxis == <pre> bitRead(variable, n); </pre> == Parámetros == ;variable: variable a evaluar. ;n: bit a leer. Empezando en 0 el menos significativo (derecha). == Retornos == 1 o 0 dependiendo del valor de dicho bit == Advertencias == Nada. == Ejemplo 1 == Revisar el bit más significativo (izquierda) es una manera alternativa para detectar un valor entero negativo en un numero tipo [[char]]. <syntaxhighlight lang="c++"> char c = 200; // Al ser un tipo de dato con signo, 200 se traduce a -56 if (bitRead(c, 7)){ Serial.println("Es negativo"); }else{ Serial.println("Es positivo"); } </syntaxhighlight> == Ejemplo 2 == Leer un [[byte]] e imprimirlo al reves (izquierda a derecha). <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); byte pinState = B10101010; for (byte i=0; i<8; i++) { Serial.print(bitRead(pinState, i)); } } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 3 == En este ejemplo usamos un 74x595 para manejar 7 LED con 3 pines de Arduino. En los LEd se mostraran los numero de 0~255 en binario. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); pinMode(9, OUTPUT); //STC (12), Latch pin pinMode(10, OUTPUT); //SHC (11), Shift register pinMode(11, OUTPUT); //DS (14), Data in } void loop(){ for (byte n=0; n<256; n++){ Serial.println(n); for (byte i=0; i<8; i++){ digitalWrite(11, bitRead(n,i)); //Ingresamos bit uno a uno digitalWrite(10, HIGH); //Pulso de Shift digitalWrite(10, LOW); } digitalWrite(9, HIGH); //Pulso de Latch digitalWrite(9, LOW); delay(500); } } </syntaxhighlight> == Ejemplo 4 == Tenemos 8 LEDs (2 al 9) y un pulsados (pin 10). Cada vez que pulsamos avanzamos '''n''' en una unidad y mostramos '''n''' en binario. <syntaxhighlight lang="c++"> const byte LED[] = {2, 3, 4, 5, 6, 7, 8, 9}; const byte boton = 10; bool actual,anterior; byte n; void setup() { for (byte i=0; i<8; i++) { pinMode(LED[i], OUTPUT); } pinMode(boton, INPUT); } void loop() { actual = digitalRead(boton); if (actual && !anterior){ n++; for (byte i=0; i<8; i++) { digitalWrite(LED[i], bitRead(n, i)); } } anterior = actual; } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones bit y byte</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones bit y byte]] e6sq7q6qeaw3bp4vm2tdl8pomzp0ah9 0 193 4703 4379 2019-07-14T17:43:11Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Establece (pone a 1) un bit de una variable numérica. == Sintaxis == <pre> bitSet(variable, n); </pre> == Parámetros == ;variable: variable a evaluar. ;n: bit a seleccionar. == Retornos == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones bit y byte</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones bit y byte]] mptebdpjdwap35u6ptg7j7ho3ybnvgq 0 194 4784 4699 2019-07-17T23:39:22Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Sobrescribe un bit según el valor ingresado. == Sintaxis == <pre> bitWrite(variable, n, valor); </pre> == Parámetros == ;variable: Variable numerica a evaluar. ;n: bit a escribir. ;valor: valor [[bool]] (o el resultado de "diferente de cero" cuando se ingresa un dato de otro tipo) a escribir en el bit. == Retornos == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> byte pinState = 0; //Inicialisa todos los pines a LOW (B00000000) bitWrite(pinState, 0, HIGH); //Pone el 1er pin en HIGH, pinState = B00000001 bitWrite(pinState, 3, HIGH); //Pone el 3er pin a HIGH, pinState = B00001001 bitWrite(pinState, 0, LOW); //Pone el 1er pin a LOW, pinState = B00001000 </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones bit y byte</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> == Referencias externos == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones bit y byte]] ac7xwy46ehrz63ajk61sdtd22q8xx94 0 106 4973 4418 2019-09-26T16:25:11Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Desplaza hacia la izquierda (hacia el bit más significativo) una cantidad determinada de bits de una variable o constante; rellenando con ceros. == Sintaxis == <pre> valor <nowiki><<</nowiki> posiciones; variable = variable <nowiki><<</nowiki> posiciones; variable <nowiki><<=</nowiki> posiciones; </pre> == Parámetros == ;valor:Constante a trabajar. Tipo [[int]] o [[long]]. ;variable:Variable a trabajar. Tipo [[int]] o [[long]]. ;posiciones:Cantidad de posiciones bit a desplazar. Valores entre 1~32. Tipo [[int]] == Comentarios == {| class="wikitable col1cen col2cen" |+Algunas operaciones basicas |- ! Operacion !! Resultado |- |1 <nowiki><<</nowiki> 0||1 |- |1 <nowiki><<</nowiki> 1||2 |- |1 <nowiki><<</nowiki> 2||4 |- |1 <nowiki><<</nowiki> 8||8 |- |1 <nowiki><<</nowiki> 8||256 |- |1 <nowiki><<</nowiki> 9||512 |- |1 <nowiki><<</nowiki> 10||1024 |} {{Nota|Ver ejemplo 2.}} == Advertencias == * Esta operación desplaza bits descartando los que hayan quedado fuera, no los rota de posición. Por lo tanto, desplazar la cantidad suficiente de bits puede resultar en un valor cero. == Ejemplo 1 == <syntaxhighlight lang="c++"> int a = B0000000000000101; //5 int b = a << 3 //B0000000000101000 osea 40 int x = B0000000000000101; //5 int y = B0000000000001110; //14 int result = x << y; //B0100000000000000 - el primer bit fue descartado </syntaxhighlight> == Ejemplo 2 == Demuestra el comentario. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); for (byte i=0; i<=10; i++) { Serial.println(1 << i); } } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 3 == Presenta manualmente un numero tipo [[int]] en binario. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); int c = 12345; for (byte bits=7; bits>-1; bits--) { if (c & (1 << bits)) { Serial.print("1"); }else { Serial.print("0"); } } } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 4 == Partiendo del valor 1, se puede obtener el resultado de una potencia con base 2. <syntaxhighlight lang="c++"> unsigned long resultado = 1; void setup(){ for (byte pot=0; pot<sizeof(unsigned long) * 8; pot++) { Serial.print("2^"); Serial.print(pot); Serial.print(" = "); resultado <<= 1; // Se desplaza una vez cada iteración de este ciclo. Serial.println(resultado); } } void loop(){ //Nada } </syntaxhighlight> Imprime los resultados desde 2 a la 0 hasta 2 a la 31. == Vea también == <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/en/language/structure/bitwise-operators/bitshiftleft/ Artículo oficial de Arduino sobre el tema (en inglés)] [[Category:Operador bit a bit]] 2qhu1kuhq4lz4rvew22e89k43603m2r 0 105 4977 4333 2019-09-26T16:27:37Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Desplaza hacia la derecha (hacia el bit menos significativo) una cantidad determinada de bits de una variable o constante; rellenando con ceros. == Sintaxis == <pre> valor <nowiki>>></nowiki> posiciones; variable = variable <nowiki>>></nowiki> posiciones; variable <nowiki>>>=</nowiki> posiciones; </pre> == Parámetros == ;valore:Constante a trabajar. Tipo [[int]] o [[long]]. ;variable:Variable a trabajar. Tipo [[int]] o [[long]]. ;posiciones:Cantidad de posiciones a desplazar. Entre 1~32. Tipo [[int]]. == Retorno == Retorna el numero numero luego del desplazamiento. == Comentarios == {| class="wikitable col1cen col2cen" |+Algunas operaciones básicas |- ! Operación !! Resultado |- |1024 <nowiki>>></nowiki> 0||1024 |- |1024 <nowiki>>></nowiki> 1||512 |- |1024 <nowiki>>></nowiki> 2||256 |- |1024 <nowiki>>></nowiki> 7||8 |- |1024 <nowiki>>></nowiki> 8||4 |- |1024 <nowiki>>></nowiki> 9||2 |- |1024 <nowiki>>></nowiki> 10||1 |} {{Nota|Ver ejemplo 2}} == Advertencias == * Esta operación desplaza bits descartando los que hayan quedado fuera, no los rota de posición. Por lo tanto, desplazar la cantidad suficiente de bits puede resultar en un valor cero. == Ejemplo 1 == <syntaxhighlight lang="c++"> int a = 0000000000101000; //40 int b = a >> 3 //B0000000000000101 osea 5 int x = B1111111111110000; //-16 int y = B0000000000000011; //3 int result = x >> y; //B1111111111111110 </syntaxhighlight> == Ejemplo 2 == Demuestra el comentario. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); for (byte i=0; i<=10; i++) { Serial.println(1024 >> i); } } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 3 == Sirve para realizar una división entera con un cociente potencia de base 2 <syntaxhighlight lang="c++"> analogWrite(pin, analogRead(A0) >> 2); // Mucho más rápido que map() o una división. </syntaxhighlight> '''analogRead(A0) >> 2''' equivale a '''analogRead(A0) / 4''' == Ejemplo 4 == Leer y escribir un dato tipo [[int]] osea dos bytes. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); //Leer int val0,dato = 12345; byte val1 = highByte(dato); //Toma mas significativo byte val2 = lowByte(dato); //Toma menos significativo //Escribir val0 = val1; //Escribe MSB val0 = val0 << 8; //Desplaza a la izquierda val0 |= val2; //Lo mismo que: val0 += val2; Serial.println(val0); } void loop(){ //Nada }</syntaxhighlight> == Ejemplo 5 == Descomponer y reconstruir un dato tipo [[long]] osea cuatro bytes. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); //Descomponer long dat1 = 123456789; Serial.println(dat1, HEX); byte val[4]; for (byte i=0; i<4; i++) { val[i] = lowByte(dat1)); dat1 = dat1 >> 8; //Desplaza 8 bits a la derecha } //Reconstruir long dat2; for (i=0; i<4; i++) { dat2 += val[3-i]; if (i != 3){ dat2 = dat2 << 8; //Desplaza 8 bits a la izquierda } } Serial.println(dat2, HEX); } void loop(){ //Nada } </syntaxhighlight> == Vea también == * [[not bit a bit]] - (<nowiki>~</nowiki>) * [[and bit a bit]] - (<nowiki>&</nowiki>) * [[or bit a bit]] - (<nowiki>|</nowiki>) * [[xor bit a bit]] - (<nowiki>^</nowiki>) * [[bitshift left]] - (<nowiki><<</nowiki>) * [[or bit a bit compuesto]] <nowiki>(|=)</nowiki> * [[and bit a bit compuesto]] <nowiki>(&=)</nowiki> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Operador bit a bit]] mmejkrmhc02xv9tp90kfkipsn0ke4y2 0 308 4542 4541 2019-06-26T23:29:39Z Kike GL 2 wikitext text/x-wiki Un '''boceto''' (sketch) es el nombre que Arduino usa para un programa. Es la unidad de código que se carga y ejecuta en una placa Arduino. Estos '''bocetos''' están escritos en el editor de texto y se guardan con la extensión de archivo .ino. El editor tiene funciones para cortar/pegar y para buscar/reemplazar texto. El área de mensajes brinda comentarios al guardar y exportar y también muestra los errores. La consola muestra el texto generado por el software [[IDE]] Arduino, incluidos los mensajes de error completos y otra información. La esquina inferior derecha de la ventana muestra la placa configurada y el puerto serie usado. Los botones de la barra de herramientas le permiten verificar y cargar programas, crear, abrir y guardar '''bocetos''' y abrir el monitor en serie para comunicarse con la placa Arduino via puerto serie (USB). <pre> <libreria> Variables globales; void setup(){ //Algo } void loop(){ //Algo } </pre> == Advertencia == EL código que pongas fuera de las llaves de [[setup()]] y [[loop()]] no se ejecutara. == Comentarios == * Dentro de las llaves de [[setup()]] debes poner lo que quieres ejecutar una sola vez al inicio. * Dentro de las llaves de [[loop()]] debes poner lo que quieres ejecutar simpre una y otra vez luego de [[setup()]]. * Las variables que definas fuera de las llaves de [[setup()]] y [[loop()]] son variables [[Variables|globales]] que pueden ser usadas en cualquier pare del '''boceto'''. == Vea también == * [[Estructura]] * [[IDE]] * [[setup()]] * [[loop()]] * [[memoria]] * [[UNO]] * [[Processing]] == Referencias == * [https://www.luisllamas.es/nuestro-primer-programa-en-arduino/ Nuestro primer programa en Arduino] - Luis Llamas * [https://www.luisllamas.es/instalar-ide-arduino/ Instalar IDE Arduino y otros software util] - Luis Llamas [[Category:Estructura]] 9g89aohbvmjtyheczofajq3texgj21p 0 52 4685 4684 2019-07-07T01:16:13Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == El tipo de dato '''bool''' o '''boolean''' ocupa un byte (8 bits) y es aquella donde sólo se pueden contener dos posibles valores: [[true / false]], [[HIGH / LOW]], 1 / 0, etc. Dicha variable puede usarse directamente como condición de un [[if... else]], [[while]] y [[do... while]]. Su uso más común es como "banderas" (flag) para cambiar un estado binario en la ejecución (como alternar entre dos jugadores en un juego por turnos), o indicar la salida de un ciclo o bucle. También se puede usar para no repetir una misma comparación en múltiples [[if... else]], al menos donde no tendría sentido verificar constantemente si el resultado pudo haber cambiado en el tiempo. {{Nota|A diferencia de otros lenguajes, en Arduino (C++), tanto para la asignación en un '''bool''' o '''boolean''', como en una condición; se pueden introducir valores que no sean de este tipo (enteros, punteros y punto flotantes). Al hacerlo, implícitamente ocurre la comparación "diferente de cero"; dicho en otras palabras, sería '''falso''' si el valor ingresado es igual a cero.}} == Sintaxis == <pre> bool variable [= valor]; </pre> == Parametros == ;variable: nombre de la variable a definir. ;valor: los posibles valores son true o false. Pero también puedes usar 0 para falso y cualquier valor diferente de 0 para true y LOW y HIGH. == Advertencias == Un '''bool''' o '''boolean''' a pesar de sólo poder almacenar dos posibles valores, siempre ocupa 1 byte en memoria. En caso de requerir múltiples variables de este tipo, pero a la vez se está quedando corto de memoria [[SRAM]]; en ese caso se recomienda usar la técnica de almacenarlos como bits en un [[byte]] (mira que un bit también tiene sólo dos posibles valores), para eso puedes usar las funciones [[bitRead()]], [[bitWrite()]], [[bitClear()]] y [[bitSet()]]. == Ejemplo 1 == <pre> bool alerta = false; bool estado = HIGH; //verdadero bool b = -15; //verdadero bool residuo = numero % 8; //falso si no hay residuo. </pre> == Ejemplo 2 == Un ejemplo de parpadeo. <pre> bool estado = false; void setup() { pinMode(LED_BUILTIN, OUTPUT); } void loop() { digitalWrite(LED_BUILTIN, estado); estado = !estado; //Invertir el valor de estado delay(500); } </pre> == Vea también == * [[not]] * [[if... else]] * [[while]] * [[byte]] * [[bitRead()]] * [[bitWrite()]] == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Tipo dato]] slesw3vh33fwdepnpv62gexjl8brzc7 0 68 5249 4196 2020-02-04T12:28:30Z Kike GL 2 /* Ejemplo 1 */ wikitext text/x-wiki == Descripción == '''break''' se usa para salir de un bucle [[for]], [[while]] o [[do... while]], pasando por alto la condición del bucle normal. También se usa para delimitar cada case dentro de un [[switch... case]]. == Sintaxis == <pre> break; </pre> == Advertencias == Nada. == Ejemplo 1 == En el ejemplo el [[for]] termina cuando '''sens > limite''' o luego de 100 lecturas, lo que ocurra primero. <syntaxhighlight lang="c++"> const int limite = 800; void setup(){ } void loop(){ for (byte x=0; x<100; x++){ analogWrite(10, x); int sens = analogRead(A0); if (sens > limite){ break; } delay(50); } } </syntaxhighlight> == Ejemplo 2 == En el ejemplo al no poner '''break''' luego de los dos primeros cases se ejecutan todos hasta '''break'''. El ultimo case no requiere break porque no hay mas detras. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); } void loop(){ if (Serial.available()){ var=Serial.read(); switch (var){ case 'A': case 'B': case 'C': Serial.println("Fue A, B o C"); break; case 'M': Serial.println("Fue M"); } } } </syntaxhighlight> == Vea también == <categorytree mode=all>Estructura control</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Estructura control]] iciqtt5g151lmcyi84vrjpwzh82y7sg 0 49 5156 5155 2020-01-24T16:41:33Z Kike GL 2 /* Comentarios */ wikitext text/x-wiki == Descripción == Un '''byte''' almacena un número sin signo de un byte (8 bits), de 0 a 255 (2^8 - 1). Alternativamente puede verse declarado como tipo '''uint8_t''' o '''unsigned char''', sin embargo funciona exactamente igual. {{Tip|Es importante tener en mente que un numero del tipo '''byte''' puede contener hasta 8 valores 0/1 (que es sinonimo de verdadero/falso) empacados en un solo '''byte''' y que se puede operar con ellos con operadores [[Estructura#Operadores_bit_a_bit|bit a bit]] y funciones internas de [[Funciones#Bit_y_Bytes|bits y byte]].}} == Sintaxis == <pre> byte variable [= valor]; uint8_t variable [= valor]; unsigned char variable [= valor]; </pre> == Parametros == ;variable: nombre de la variable. ;valor: valor entre 0~255. Parámetro opcional. {| class="wikitable col2cen" |+Posibles formateadores !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1111011 |} == Comentarios == * '''unsigned char''' o '''uint8_t''' es lo mismo que '''byte''' y se prefiere este ultimo. * La variable del tipo '''byte''' almacenan numero entre 0 y 255 osea 256 números. Ahora te pregunto cuanto es 0 - 1 ? en nuestro ejemplo la respuesta correcta es 255 porque es el numero que esta antes de 0. Exactamente por el otro extremo el numero que sigue de 255 es 0. A esto se le llama lógica boleana. Ahora supongamos que quieres prende un foco por 10 números e inicias el proceso en 22, por lo que preguntas if (números - tiempo = 10), se apagaría cuando números llegue a 32 (32 - 22 = 10). Ahora supón que se prende en 250, cuando apagara ? la respuesta es cuando números llegue a 5 (5 - 250 = 10). == Advertencias == * Si sumas 1 al valor máximo que de 255 pasa a 0. * Si restas 1 al valor mínimo que de 0 pasa a 255. <syntaxhighlight lang="c++"> byte a = 255; a++; //a es 0 byte b = 0; b--; //b es 255 </syntaxhighlight> == Ejemplos 1 == <syntaxhighlight lang="c++"> byte n = 'A'; byte n = 65; //Valor ASCII de letra A uint8_t n = 65; byte x = 0x41; //0x = formato hexadecimal, 65 byte x = 0101; //0 = formato octal, 65 byte x = B1000001; //B = formato binario, 65 </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> byte x, y, z = 12; //Error, x e y están declaradas pero no inicializadas. byte x = 12,y = 12,z = 12; //Ok </syntaxhighlight> == Ejemplo 3 == En este ejemplo hacemos la variable byte igual a un '''caracter'''. <syntaxhighlight lang="c++"> void setup() { Serial.begin(115000); Serial.println("Letras mayusculas:"); for (char c='A'; c<='Z'; c++){ Serial.write(c); //Imprime el carácter Serial.print(", dec: "); Serial.println(c); //Imprime su valor ASCII decimal delay(100); } } void loop() { //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/variables/constants/integerconstants/ Guia de referencia de Arduino] [[Category:Tipo dato]] juy3rw2i4lxfku7xk39m5kcv0koxw7x 0 175 4307 4228 2019-06-11T23:45:46Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Convierte un valor en un dato tipo [[byte]]. == Sintaxis == <pre> byte(variable); </pre> == Parametros == ;variable: una variable de tipo [[String]]. == Retorna == Retorna un numero tipo [[byte]]. == Advertencias == No funciona con cadenas [[string]] ni objetos [[String]]. == Ejemplo == <syntaxhighlight lang="c++"> char a = 'A'; byte b = 123; void setup(){ Serial.begin(9600); byte valor1 = byte(a); Serial.println(valor1); //65 int valor2 = long(b); Serial.println(valor2); //123 unsigned int valor3 = word(b); //123 Serial.println(valor3); long valor4 = long(b); //123 Serial.println(valor4); } void loop(){ //Nada. } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones conversion]] 7ip7qlhm3qxd478f4fzwqza2jodbw7m 0 369 4845 2028 2019-07-25T00:53:01Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == == Sintaxis == <pre> </pre> == Parámetros == == Retorno == == Comentarios == == Advertencias == == Ejemplo == <pre> </pre> == Vea también == * [[free()]] * [[malloc()]] * [[realloc()]] == Referencias == [[Category:Funciones]] 3y7f9g6e0q3rlrtkioh62lolxb2ufqw 0 173 4285 4209 2019-06-11T23:33:18Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Redondea un numero [[float]] hacia arriba. == Sintaxis == <pre> ceil(valor); ceil(variable); </pre> == Parámetros == ;valor: valor tipo [[float]] a operar. ;variable: nombre de variable tipo [[float]] a operar. == Retorno == Retorna un numero tipo [[long]]. == Advertencias == Nada. == Ejemplo == <pre> ceil(PI); //4 </pre> == Vea también == <categorytree mode=all>Funciones matematicas</categorytree> == Referencias externas == [[Category:Funciones matematicas]] rnj41ckk6eaiextll3ea70w83ph1ggx 0 51 3672 3671 2019-05-06T18:38:01Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Un '''char''' (caracter) es el tipo de dato mas pequeño para el almacenamiento de números en Arduino porque almacena un valor de 1 byte (8 bit). Esto produce un rango de -128 (-2^7) a 127 (2^7-1). Mucha gente asocia, quizas por su nombre, que este tipo de datos solo almacena un carácter como tal. Eso es cierto, pero olvida que la logica digital solo conoce de unos y ceros, por lo que en realidad lo que almacena es el código ASCCI de dicho caracter. Cada caracter esta representado por un número entero; y su relación símbolo-valor la podemos encontrar en la llamada [https://es.wikipedia.org/wiki/ASCII#Caracteres_imprimibles_ASCII Tabla ASCII]. Es más, es posible realizar operaciones matemáticas sobre caracteres individuales debido a la razón anterior; pudiendo resultar en otro carácter. Ver ejemplo 4. == Sintaxis == <pre> char variable [= valor]: </pre> == Parametros == ;variable: nombre de la variable. ;valor: puede ser un numero en el rango, aunque normalmente suele ser un carácter entre comillas simples y lo que se almacena es su valor ASCII. Parámetro opcional. {| class="wikitable col2cen" |+Posibles formateadores !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1110011 |} == Advertencias == * No es lo mismo asignar un valor entero que un caracter. '''Por ejemplo:''' 1 no es lo mismo que '1' ya que, según la tabla ASCII, este último en realidad equivale a 49. Sin embargo, ambos pueden convivir para ciertas funciones; como obtener el carácter que representa la unidad de un número entero: <syntaxhighlight lang="c++"> int valor = 536; char unidad = '0' + (valor % 10); // A partir de aquí debería de tener asignado el caracter '6' </syntaxhighlight> * Si sumas 1 al valor maximo que de 127 pasa a -128. * Si restas 1 al valor minimo que de -128 pasa a 127. == Comentarios == * Solamente los caracteres ASCII están estandarizados en todas las regiones del mundo y librerías para Arduino; la codificación del rango extendido (la parte negativa del '''char''' o la que va de 128 a 255) suele variar según la implementación. Un típico ejemplo es el problema de imprimir la 'ñ' en el monitor serial, o imprimir el símbolo de grados ('°') en un LCD de caracteres; ambos están en la parte extendida, por eso puede darnos resultados inesperados. Es también por esta razón que si encontramos código con literales (cadenas de caracteres) de un idioma que no utiliza las letras del alfabeto latino (como el ruso o japonés), al imprimirlos en el monitor serial, nos aparece como "basura". * Hay que notar el [[Serial.print()]] trata de manera diferente a '''char''' que otros tipos como: [[byte]], [[int]], [[float]], etc == Ejemplo 1 == En todos los casos la variable '''caracter'' tomara el mismo valor. <syntaxhighlight lang="c++"> char caracter = 'A'; char caracter = 65; //DEC char caracter = 0x41; //HEX char caracter = 0101; //OCT char caracter = B1000001; //BIN </syntaxhighlight> # Si revisas la [[ASCII table|tabla ASCII]], habrás notado que sigue siendo la misma asignación. Recuerda que para asignar caracteres individuales, estos deben estar entre '''comillas simples'''. # Es un dato de número decimal entero; por lo tanto esta asignación es válida. # Es la misma asignación que el anterior, solo que el valor es hexadecimal. Puede ser útil ya que algunas veces nos dan la tabla con valores en hexadecimal. # Es la misma asignación que el anterior, solo que el valor es octal. # Es la misma asignación que el anterior, solo que el valor es binario. == Ejemplo 2 == Asignacion multiple. <syntaxhighlight lang="c++"> char x, y, z = 12; //Error, x e y están declaradas pero no inicializadas. char x = 'A',y = 12,z = 'Z'; //Ok </syntaxhighlight> == Ejemplo 3 == Lo que se encierra entre '''comillas dobles''' se conoce como un literal; que básicamente es una matriz (array en ingles) o vector de caracteres (en especial por los <nowiki>[]</nowiki> en el nombre de la variable). <syntaxhighlight lang="c++"> char texto[] = "Hola mundo de Arduino!"; </syntaxhighlight> == Ejemplo 4 == Este ejemplo muestra como encendemos el LED a bordo enviando desde el monitor serie la letra '''e''' y lo apagas con la letra '''a'''. <syntaxhighlight lang="c++"> void setup(){ pinMode(LED_BUILTIN, OUTPUT); } void loop(){ if (Serial.available()) { char entrada = Serial.read(); if (entrada == 'e'){ digitalWrite(LED_BUILTIN, HIGH); //Enciende LED }else if (entrada == 'a'){ digitalWrite(LED_BUILTIN, LOW); //Apaga LED } } } </syntaxhighlight> == Ejemplo 5 == Si te preguntas si el tipo '''char''' acepta negativos aquí la demostración. <syntaxhighlight lang="c++"> void setup() { Serial.begin(115200); } void loop() { if (Serial.available()) { char c = Serial.read(); Serial.print("Enviaste: "); Serial.writen(c); //Muestra la letra Serial.println(c, DEC); c = c - 80; Serial.print("Queda: "); Serial.println(c, DEC); } } </syntaxhighlight> == Ejemplo 6 == En este ejemplo hacemos la variable char igual a un '''numero'''. El monitor serie solo puede interpretar los caracteres entre 33~126. <syntaxhighlight lang="c++"> void setup() { Serial.begin(115000); Serial.println("Mapa tabla ASCII:"); for (char c=33; c<=126; c++){ Serial.print(c); //Imprime el carácter Serial.print(", dec: "); Serial.print(c, DEC); //Imprime su valor ASCII decimal delay(100); } } void loop() { //Nada } </syntaxhighlight> {{Nota|Si usas [[byte]], [[int]], [[float]], etc en lugar de '''char''' debes reemplazar el primer Serial.print() por Serial.write().}} == Ejemplo 7 == En este ejemplo hacemos la variable char igual a un '''caracter'''. <syntaxhighlight lang="c++"> void setup() { Serial.begin(115000); Serial.println("Letras mayusculas:"); for (char c='A'; c<='Z'; c++){ Serial.print(c); //Imprime el carácter Serial.print(", dec: "); Serial.println(c,DEC); //Imprime su valor ASCII decimal delay(100); } } void loop() { //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/variables/data-types/char/ Guia de referencia de Arduino] [[Category:Tipo dato]] 3zj7uizh1oraejj990fki31qkrgb3jl 0 54 4489 4308 2019-06-24T22:53:36Z Kike GL 2 /* Advertencias */ wikitext text/x-wiki == Descripción == Convierte valor numerico a un dato tipo [[char]]. == Sintaxis == <pre> char(variable); </pre> == Parámetros == ;variable: variable de cualquier tipo a evaluar. == Retorna == Retorna un [[char]]. == Advertencias == No funciona con cadenas [[string]] o matrices ni objetos [[String]]. == Ejemplo == <syntaxhighlight lang="c++"> char a = 'A'; byte b = 123; void setup(){ Serial.begin(9600); byte valor1 = byte(a); //65 Serial.println(valor1); int valor2 = long(b); Serial.println(valor2); //123 unsigned int valor3 = word(b); Serial.println(valor3); //123 long valor4 = long(b); Serial.println(valor4); //123 } void loop(){ //Nada. } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> * [[atoi()]] desde matriz * [[atol()]] desde matriz * [[strtoul()]] desde matriz * [[atof()]] desde matriz * [[objeto.getBytes()]] desde String * [[objeto.toInt()]] desde String * [[objeto.toFloat()]] desde String == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones conversion]] s1fi4egx62gr8fegte0ubd4gw0og5ea 0 53 5221 5204 2020-02-02T05:26:14Z Kike GL 2 /* Ejemplos */ wikitext text/x-wiki == Descripción == Palabra clave conocida como '''calificadora'''. Hace que el valor asignado inicialmente no pueda ser cambiado tras la inicializacion. Se usa antes del tipo de datos de una variable, para modificar la manera en que el compilador y el [[boceto]] deben tratar dicha variable. Las constantes son números que se usan directamente en un [[boceto]], como 123 o 3.1416. De forma predeterminada, estos números se tratan como: [[int]] (contantes enteras) o [[float]] (constantes de coma flotante), pero puede cambiar esto incluyendo en '''tipo''' o un subfijo modificador: U (unsigned), L (long) o F (float). {{Nota|Una diferencia importante entre usar '''const''' o no es que al usarla la variable es almacenada en la memoria [[flash]] en lugar de la escasa [[SRAM]].}} == Sintaxis == <pre> const [tipo] variable = valor; </pre> == Parámetros == ;tipo: elegir el tipo de dato a almacenar: [[char]], [[byte]], [[int]], [[long]], [[float]], etc de manera explicita o si prefiere puede añadir un subfijo al valor: {| class="wikitable col2cen" |+Subfijos !Tipo!!Subfijo!!Ejemplo |- |[[int]]||ninguno||123 |- |[[unsigned int]]||U||123U |- |[[long]]||L||123L |- |[[unsigned long]]||UL||123UL |- |[[float]]||F||1.23F |} ;Variable: nombre de variable a definir. ;valor: valor a almacenar en el rango del tipo de dato. Puede usar un prefijo para indicar la '''base''' en que esta expresado valor. {| class="wikitable col2cen" |+Prefijos !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1110011 |} == Comentarios == * El [[IDE]] dara un error de compilación si se intenta asignar un nuevo valor a una variable '''const''' lo que protege al programador contra un posible error. * Todas las variables son almacenadas en [[SRAM]] salvo '''const''' que es almacenada en [[flash]]. == Advertencias == * Debe preferir '''const''' en lugar de [[define]]. == Ejemplos == <syntaxhighlight lang="c++"> const n = 123; //int const n = 33U; //unsigned int const n = 9L; //long const n = 32189UL; //unsigned long const n = 3.14F; //float const byte n = 123; const byte n = B1110011; //binario const byte n = 0173; //Octal const byte n = 0x7B; //Hexadecimal </syntaxhighlight> == Vea también == * [[Palabras reservadas]] * [[variable publica]] * [[variable local]] * [[static]] * [[volatile]] * [[extern]] * [[define|#define]] * [[matriz]] * [[Comentarios]] - <nowiki>(//)</nowiki> == Referencias == * [https://www.prometec.net/intro-programacion/ Introduccion a la programacion en Arduino] - Prometec * [http://www.electrogeekshop.com/diferencia-entre-define-y-const-en-arduino/ Diferencia entre define y const en Arduino] - ElectroGeek * [https://aprendiendoarduino.wordpress.com/tag/constantes/ Variables en Arduino] - Enrique Crespo [[Category:Variables]] apky4cr9yefeczvlik3qcaaj44f3mme 0 165 5165 5164 2020-01-31T23:52:05Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Restringe un número para estar dentro de un rango. == Sintaxis == <pre> constrain(variable, min, max); </pre> == Parámetros == ;variable: Nombre variable numerica a restringir. Cualquier tipo de dato. ;min: valor minimo ;max: valor maximo. == Retorna == * Retorna la '''variable''' si esta entre min y max. * Retorna la '''min''' si variable <nowiki><</nowiki> min. * Retorna la '''max''' si variable <nowiki>></nowiki> max. == Advertencias == Nada. == Ejemplo == Limita los valores entre 10 y 150. <pre> dato2 = constran(dato1, 10, 150); </pre> == Vea también == <categorytree mode=all>Funciones matematicas</categorytree> == Referencia externas == * [https://www.arduino.cc/reference/en/language/functions/math/constrain/ Guia de referencia] [[Category:Funciones matematicas]] tctnwn24rxjvlc36azd2ry19xh5sf64 0 86 4197 4182 2019-06-11T21:15:38Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == El comando '''continue''' omite el resto de la iteración actual de un ciclo en [[for]], [[while]] o [[do... while]]. Continúa comprobando la expresión condicional del ciclo y avanzando con cualquier iteración posterior. == Sintaxis == <pre> continue; </pre> == Comentarios == == Advertencias == Nada. == Ejemplo == En este ejemplo hacemos que no cambie el [[analogWrite()]] en el rango de 41~119. <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Estructura control</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Estructura control]] 158xmrg7duqq61ssceddgcdz5lkjhdl 0 38 4474 4470 2019-06-24T22:39:15Z Kike GL 2 /* Retornos */ wikitext text/x-wiki == Descripción == Calcula el coseno de un ángulo (en radianes). El resultado está comprendido entre -1 y 1. == Sintaxis == <pre> cos(rad); </pre> == Parámetros == ;rad: el ángulo en radianes [[float]] == Retornos == El coseno del ángulo [[float]]. Valores entre -1 y +1. == Advertencias == * El angulo debe estar expresado en radianes entre 0 y [[PI|TWO_PI]]. == Ejemplo 1 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); Serial.println(cos(0), 3); //1.000 Serial.println(cos(HALF_PI/2), 3); //0.707 Serial.println(cos(HALF_PI), 3); //0.000 Serial.println(cos(PI), 3); //-1.000 Serial.println(cos(PI+HALF_PI), 3); //0.000 Serial.println(cos(TWO_PI), 3);} //1.000 void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ for (float n=0; n<TWO_PI; n+=0.01){ Serial.println(cos(n)); } } </syntaxhighlight> == Vea también == * [[sin()]] * [[tan()]] * [[asin()]] * [[acos()]] * [[atan()]] * [[PI]] == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones trigonometricas]] 5g01ijcvs3szd2gyjv35l82sla84jwl 0 212 5034 4732 2019-09-27T00:20:43Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Decrementa en uno la variable dada. {{Nota|Es lo mismo que variable <nowiki>=</nowiki> variable - 1.}} == Sintaxis == <pre> variable--; --variable; variable = variable - 1; </pre> == Retorno == Valor de la variable disminuido en uno. == Comentarios == * Cual es la diferencia entre poner el operador delante o atrás de nombre de la variable ? == Advertencias == * El riesgo del desbordamiento (ir más allá de lo que una variable puede almacenar, su rango de valores) sigue estando presente. En este caso sería volver a su valor máximo o pasar a un número positivo. == Ejemplo 1 == Desbordamos el byte. <syntaxhighlight lang="c++"> byte n = 1; n--; //0 n--; //255 n--; //254 </syntaxhighlight> == Ejemplo 2 == Nota la diferencia de poner delante o detras. <syntaxhighlight lang="c++"> byte x = 2; y = --x; //x=1 y=1 y = x--; //x=0 y=1 </syntaxhighlight> == Ejemplo 3 == Es muy comun usarlo en un [[for]] para hacer cuanta descendente. <syntaxhighlight lang="c++"> void setup(){ } void loop(){ for (byte n=9; n>=0; n--){ //Repite 10 veces. } } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> <categorytree mode=all>Operador logico</categorytree> == Referencias == [[Category:Operador aritmetico]] jefj3rrhozsxu9v2x2508axfdzeptpk 0 443 5207 5206 2020-02-02T04:38:25Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == '''#define''' permite al programador dar un nombre a un valor constante antes de compilar el [[boceto]]. Las constantes definidas en Arduino no ocupan ningún espacio de memoria [[SRAM]] ya que el compilador reemplaza las referencias a estas constantes con por su valor definido en tiempo de compilación. Esto puede tener algunos efectos secundarios no deseados, sin embargo, si por ejemplo, un nombre de la constante que había sido definido con #defined está incluido en algún otro nombre de constante o variable. En ese caso el texto se sustituye por el número #defined (o texto). En general, se prefiere la palabra clave [[const]] para las constantes que se definen y se debe usar en lugar de #define. == Sintaxis == <pre> #define variable valor </pre> == Parámetros == ;variable:nombre de la constante ;valor:a reemplazar == Retorno == Ninguno. == Advertencia == Debe empezar con # y no debe haber ; al final de la linea == Ejemplo == <syntaxhighlight lang="c++"> #define LED = 13 void setup(){ pinMode(LED, OUTPUT); } void loop(){ //Nada } </syntaxhighlight> Al momento de compilar hace una macrosustitucion y queda asi: <syntaxhighlight lang="c++"> void setup(){ pinMode(13, OUTPUT); } void loop(){ //Nada } </syntaxhighlight> == Vea también == * [[variable publica]] * [[variable local]] * [[matriz]] * [[include]] * [[const]] * [[extern]] * [[volatile]] == Referencias == * [http://manueldelgadocrespo.blogspot.com/p/define.html define] - Manuel Delgado [[Category:Variables]] t6vwmwtxepo2pyv9oiuh4veu6t3csqu 0 29 4921 4920 2019-09-21T14:02:17Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Hace una pausa en el boceto durante el tiempo (en milisegundos) especificado como parámetro. (1 segundo = 1000 milisegundos) {{Tip|Los programadores serios evitan el uso de '''delay()''' para la sincronización de los eventos de más de 10 milisegundos a menos que el [[boceto]] sea muy simple. Se recomienda usar [[millis()]] en su lugar.}} == Sintaxis == <pre> delay(ms); </pre> == Parámetros == ;ms: el número de milisegundos para hacer una pausa, tipo [[unsigned long]]. == Retornos == Nada. == Advertencias == * Si bien es fácil crear un LED parpadeante con la función '''delay()''' y muchos ejemplos usan retardos cortos para tareas tales como supresión de [[Rebote]]s de un pulsador, el uso de la funcion delay() en un [[boceto]] tiene inconvenientes significativos. Ninguna lectura de los sensores, cálculos matemáticos, o la manipulación de pines puede realizarse hasta que la función '''delay()''' termine. Un enfoques alternativo para controlar del tiempo es la función [[millis()]] porque el boceto continua ejecutando. * Ciertas cosas si funcionan mientras que la función '''delay()''' está controlando Arduino, debido a que la función '''delay()''' no deshabilita las interrupciones y están funcionan como es debido, así mismo la comunicación serie y [[analogWrite()|PWM]] continua normalmente. == Ejemplo == <syntaxhighlight lang="c++"> const byte led = 13; //LED void.setup() { pinMode (led, OUTPUT); //Establece el pin digital como salida } void.loop() { digitalWrite(led, HIGH); //Prende LED delay(500); //Espera medio segundo digitalWrite(ledPin, LOW); //Apaga LED delay(500); //Espera medio segundo } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones tiempo</categorytree> * [[Tip 3]] == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/delay/ Guía de Referencia de Arduino] [[Category:Funciones tiempo]] bjbrbibcrgfii72mqh6r1swvl3ivsp3 0 44 4281 4236 2019-06-11T23:28:49Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Pausa la ejecución del programa durante la cantidad de microsegundos especificada. Al igual que [[delay()]], no interfiere en las salidas PWM ni en las tareas en segundo plano (interrupciones). Este retraso lo realiza con la mayor exactitud posible que pueda ofrecer el sistema; tanto así que para ciertas frecuencias de reloj, utiliza instrucciones en lenguaje ensamblador para mantener la sincronía. == Sintaxis == <pre> delayMicroseconds(tiempo); </pre> == Parámetros == ;tiempo: el lapso (en microsegundos) en el que el programa se detiene ([[unsigned int]]). == Retornos == Nada. == Advertencias == * Debido a que esta función no interfiere con las interrupciones, estas podrían comprometer fuertemente la exactitud del retraso (lo prolongan más de lo que debería). A menos que las deshabilites con [[noInterrupts()]] o lo hagas dentro de una rutina de este tipo, no se recomienda utilizar esta función para generar (o leer) trenes de pulsos cuyo margen de error sea muy pequeño. == Comentarios == * A diferencia de [[delay()]], [[millis()]] y [[micros()]], esta función no depende de temporizador alguno; lo que lo vuelve utilizable sin interrupciones o dentro de una rutina de interrupción (aunque en la mayoría de casos se desaconseja su uso). * A pesar de ser algo inusual (y en cierto modo hasta absurdo pensar), debido al tipo de parámetro, es posible realizar un retraso de 65535 microsegundos (casi como hacer '''delay(66)''') o 4294967296 microsegundos (4295 segundos o 1 hora y 12 minutos); dependiendo de la arquitectura del microcontrolador. * Colocar un cero de parámetro es prácticamente el equivalente a colocar un uno; solamente el proceso que "por debajo" conlleva invocar una función y salir de esta, ya genera un retraso de esa duración. Dicho efecto se vuelve despreciable en microcontroladores que trabajan a 40 MHz o más. == Ejemplo == <syntaxhighlight lang="c++"> while (true) { digitalWrite(pin, HIGH); delayMicroseconds(500); digitalWrite(pin, LOW); delayMicroseconds(500); } // Genera una señal cuadrada de más o menos 1 KHz. El sobrecargo del ciclo hace este proceso un tantito más lento, y además las ocasionales interrupciones hacen que dicha frecuencia no se mantenga estable. </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones tiempo</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones tiempo]] b7brhmfu13ys1kd3kkn9vj7lrin6l8z 0 41 4262 1760 2019-06-11T23:10:52Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Desconecta la interrupción dada. == Sintaxis == <pre> detachInterrupt(interrupt); detachInterrupt(digitalPinToInterrupt(pin)); detachInterrupt(pin); //solo DUE, Zero y MKR100 </pre> == Parámetros == ;interrupt: el número de interrupción a deshabilitar. Ver [[attachInterrupt()]] para más detalles. ;pin: el número de pin de la interrupción a deshabilitar (solo DUE, Zero y MKR100) == Retornos == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> const byte pulsador = 2; volatile bool estado = LOW; void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(pulsador, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(pulsador), parpadea, CHANGE); } void parpadea(){ estado = !estado; } void loop(){ digitalWrite(LED_BUILTIN, estado); } </syntaxhighlight> == Vea también == * [[attachInterrupt()]] * [[interrupts()]] * [[noInterrupts()]] == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [http://www.gammon.com.au/interrupts Nick Gammon] [[Category:Funciones interrupciones]] 8gwmo9rr4v9etxe5su1ve427f00d523 0 100 4997 4713 2019-09-26T23:39:43Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Comparador de desigualdad. Que son diferentes. == Sintaxis == <pre> variable != valor; variable != expresion; variable1 != variable2; </pre> == Retorna == Verdadero si son diferentes y falso si son iguales. == Advertencias == Nada, == Ejemplo == <pre> if (a != b){ //Son diferentes }else{ //Son iguales } </pre> == Vea también == <categorytree mode=all>Operador logico</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Operador comparador]] qw9b0ualumqlp7cwzl67g1i7ydmr3a3 0 284 4265 1126 2019-06-11T23:12:13Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Esta función no permite traducir el pin digital real al número de interrupción específico. Normalmente, debe usar '''digitalPinToInterrupt(pin)''', en lugar de colocar un número de interrupción directamente en su boceto. Los pines específicos con interrupciones, y su asignación para interrumpir el número varía en cada tipo de placa. El uso directo de números de interrupción puede parecer simple, pero puede causar problemas de compatibilidad cuando el boceto se ejecuta en una placa diferente. Sin embargo, los bocetos más antiguos a menudo tienen números de interrupción directa. A menudo se usaron el número 0 (para el pin digital 2) o el número 1 (para el pin digital 3). La tabla a continuación muestra los pines de interrupción disponibles en varios Arduinos. {| class="wikitable col2cen col3cen col4cen col5cen col6cen" |+Pines de interrupcion en Arduino !Arduino!!INT.0!!INT.1!!INT.2!!INT.3!!INT.4!!INT.5 |- |[[UNO]]||2||3||&nbsp;||&nbsp;||&nbsp;||&nbsp; |- |[[MEGA]]||2||3||21||20||19||18 |- |32u4||3||2||0||1||7||&nbsp; |- |[[DUO]]||colspan=6|Todos los pines |} Tenga en cuenta que en la tabla a continuación, los números de interrupción se refieren al número que se pasará a [[attachInterrupt()]]. Por razones históricas, esta numeración no siempre se corresponde directamente con la numeración de interrupción en el chip ATmega (por ejemplo, int.0 corresponde a INT4 en el chip ATmega2560). == Sintaxis == <pre> digitalPinToInterrupt(pin); </pre> == Parametros == ;pin: numero de pin == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == * [[attachInterrupt()]] * [[detachInterrupt()]] * [[interrupts()]] * [[noInterrupts()]] == Referencias externas == [[Category:Funciones interrupciones]] el3e7xf9z09fzkzb33s64ktn7mk50ow 0 26 5053 5051 2019-10-07T22:02:40Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Lee el valor del pin digital dando un resultado. Los valores pueden ser [[HIGH / LOW]]. {{Tip|Los pines tanto analógicos como digitales de '''entrada''' no necesitan ser definidos con [[pinMode()]].}} == Sintaxis == <pre> digitalRead(pin); </pre> == Parámetros == ;pin: es el numero del pin digital a usar (0~13 + 14~19). Puedes usar [[const]] [[byte]] para de definir el numero de pin. == Retorno == Devuelve el valor del pin: [[HIGH / LOW]]. == Comentarios == {{Tip|Este comando tarda 58 ciclos de CPU en salidas digitales sin PWM y 72 ciclos en salidas digitales con PWM.}} == Advertencias == En muchos ejemplo se ve que usan una variable de tipo [[int]] para definir el pin a usar. Esto es un grave error por dos motivos: # La variable sera almacenada en memoria [[SRAM]] porque se espera que su valor cambie durante la ejecución del [[boceto]], pero normalmente en los pines esto nunca ocurre, por lo que es preferible usar [[const]] que es almacenada en [[flash]]. # El tipo [[int]] ocupa 2 byte. Es suficiente usar el tipo [[byte]] (0~255) que solo ocupa 1 byte. == Ejemplo 1 == Cuando presionamos el pulsador el LED a bordo se prende, soltamos y se apaga. Poner un pulsador entre pin digital 3 y GND. <syntaxhighlight lang="c++"> void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(3, INPUT_PULLUP); } void loop(){ if (digitalRead(3) == LOW){ digitalWrite(LED_BUILTIN, HIGH); //Prende LED }else{ digitalWrite(LED_BUILTIN, LOW); //Apaga LED } } </syntaxhighlight> {{Nota|digitalRead() retorna un verdadero mientas no estas pulsando el botón gracias a su configuración INPUT_PULLUP, asi que es exactamente lo mismo si pones '''!digitalRead(3)''' como condición. Ver Ejemplo 1a.}} == Ejemplo 1a == Cuando presionamos el pulsador el LED a bordo se prende, soltamos y se apaga. Poner un pulsador entre pin digital 3 y GND. <syntaxhighlight lang="c++"> void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(3, INPUT_PULLUP); } void loop(){ if (!digitalRead(3)){ digitalWrite(LED_BUILTIN, HIGH); //Prende LED }else{ digitalWrite(LED_BUILTIN, LOW); //Apaga LED } } </syntaxhighlight> == Ejemplo 1b == Cuando presionamos el pulsador el LED a bordo se prende, soltamos y se apaga. Poner un pulsador entre pin digital 3 y GND. <syntaxhighlight lang="c++"> void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(3, INPUT_PULLUP); } void loop(){ if (!digitalRead(3)){ digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); //Conmuta LED } } </syntaxhighlight> == Ejemplo 2 == Cuando presionamos una vez el pulsador el LED a bordo se prende. Pulsamos nuevamente y se apaga. Poner un pulsador entre pin digital 2 y GND. <syntaxhighlight lang="c++"> bool valor,anterior; void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(2, INPUT_PULLUP); } void loop(){ valor = digitalRead(2); if (!valor && anterior){ digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); //Conmuta LED } anterior = valor; } </syntaxhighlight> == Ejemplo 3 == Cada vez que presionamos el pulsador cuenta una mas en binario. Poner un pulsador entre pin digital 2 y GND, mas 8 LED en pines 3 al 10 con su respectiva resistencia de 330 ohms. <syntaxhighlight lang="c++"> bool valor,anterior; byte n; void setup(){ pinMode(2, INPUT_PULLUP); for (byte i=3; i<11; i++){ pinMode(i, OUTPUT); } } void loop(){ valor = digitalRead(2); if (!valor && anterior){ n++; } anterior = valor; for (byte i=3; i<11; i++){ digitalWrite(i, bitRead(n, i-3)); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones pines</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/variables/constants/constants/ Niveles lógicos en Arduino] * [https://playground.arduino.cc/ArduinoNotebookTraduccion/DigitalIO Playground] * [https://programarfacil.com/podcast/26-arduino-entradas-y-salidas/ Entradas y salidas] - Luis del Valle * [https://www.luisllamas.es/salidas-digitales-en-arduino/ Salidas digitales en Arduino] - Luis Llamas * [https://naylampmechatronics.com/blog/39_Resistencias-Pull-Up-y-Pull-Down.html Pull-Up y Pull-Down] - Laylamp * [https://itp.nyu.edu/physcomp/lessons/microcontrollers/digital-input-output/ Digital input/output] - ITP Informatica Fisica * [http://arduino.perut.org/Arduino_17.htm Puertos Arduino] - Kike_GL [[Category:Funciones pines]] orbxwxhak5dxqac08aw44fobueqvtmg 0 27 4770 4769 2019-07-17T21:50:51Z Kike GL 2 /* Comentarios */ wikitext text/x-wiki == Descripción == Envía al puerto digital definido previamente como OUTPUT el valor HIGH o LOW (poniendo en 1 o 0 la salida). El pin se puede especificar ya sea como una variable o como una constante (0~13 + 14~19). {{Nota|Debes usar [[pinMode()]] para hacer la definición previamente.}} == Sintaxis == <pre> digitalWrite(pin, valor); </pre> == Parámetros == ;pin: es el numero del pin digital a usar (0~13 + 14~19). Puedes usar [[const]] [[byte]] para de definirla. ;valor: por lo general se usa las palabras reservadas HIGH o LOW, pero puedes usar 0, 1, false o true. Puedes usar una variable [[byte]] para definirla. == Retorno == Nada. == Comentarios == * Los terminales de Arduino, por defecto, están configurados como entradas, por lo tanto no es necesario definirlos en el caso de que vayan a trabajar como entradas. * Los pines configurados como INPUT (entrada) quedan, bajo el punto de vista eléctrico, como entradas en alta impedancia. * Los pines configurado como OUTPUT (salida) se dice que están en un estado de baja impedancia y pueden proporcionar 40 mA de corriente a otros dispositivos y circuitos. Esta corriente es suficiente para alimentar un LED (no olvides poner una resistencia en serie de 220 ohms o mas), pero no es lo suficiente grande como para alimentar cargas de mayor consumo como relés o motores. * Un cortocircuito en las patillas Arduino provocará una corriente elevada que puede dañar o destruir el chip ATmega. {{Tip|Este comando tarda 63 ciclos de CPU en salidas digitales sin PWM y 77 ciclos en salidas digitales con PWM.}} {| class="wikitable col2cen col3cen" |+Velocidad de reacción |- ! Metodo !! KHz !! Ciclos |- | digitalWrite() || 142 || 56 |- | CLR() || 4000 || 2 |- | PORTB <nowiki>|=</nowiki> _BV() || 4000 || 2 |} == Advertencias == En muchos ejemplo se ve que usa una variable de tipo [[int]] para definir el pin a usar. Esto es un grave error por dos motivos: # Una variable sera almacenada en memoria [[SRAM]] porque se espera que su valor cambie durante la ejecución del [[boceto]], pero normalmente en los pines esto nunca ocurre, por lo que es preferible usar [[const]] que es almacenada en [[flash]]. # El tipo [[int]] ocupa 2 byte. Es suficiente usar el tipo [[byte]] (0~255) que solo ocupa 1 byte. == Ejemplo 1 == Estos comando se ejecuta una sola vez al estar en [[setup()]]. <syntaxhighlight lang="c++"> void setup(){ for (byte n=2; n<=7; n++){ pinMode(n, OUTPUT); } pinMode(17, OUTPUT); digitalWrite(2, HIGH); digitalWrite(3, LOW); digitalWrite(4, 1); digitalWrite(5, 0); digitalWrite(6, true); digitalWrite(7, false); digitalWrite(17, HIGH); //Pone en HIGH el pin analogico A3 } void loop(){ //nada } </syntaxhighlight> == Ejemplo 2 == Primero se preparan los pines digitales 6~10 como salidas. Luego se conmutan (se prende si esta apagado y viceversa) cada medio segundo alternativamente cada LED. Debes conectar 5 LED con sus respectivas resistencias de 220 ohms. <syntaxhighlight lang="c++"> void setup(){ for (byte i=6; i<=10; i++){ pínMode(i, OUTPUT); digitalWrite(i, LOW); } } void loop(){ for (byte i=6; i<=10; i++){ digitalWrite(i, !digitalRead(i)); delay(500); } } </syntaxhighlight> == Ejemplo 3 == Parpadea el LED a bordo. <syntaxhighlight lang="c++"> void setup() { DDRB = DDRB | 32; //Configura el pin digital 13 como OUTPUT, no altera el resto. 32=B00100000; } void loop() { PORTB = PORTB ^ 32; //Invertido estado del bit 5 (pin digital 13), no altera el resto. delay(500); } </syntaxhighlight> == Ejemplo 4 == Tenemos 2 pulsadores, uno para prender (boton1) y otro para apagar (boton2) un LED . Pero si pulsamos 3 veces seguidos el boton1 se apaga el LED y se prende el LED a bordo indicando un bloqueo durante 15 segundos. <syntaxhighlight lang="c++"> const byte boton1 = 2; //Boton prender y bloquear const byte boton2 = 3; //Bontos apagar const byte LED = 5; //LED bool val1, anterior1, val2, anterior2, estado, parar; byte n; unsigned long t; void setup(){ Serial.begin(9600); pinMode(boton1, INPUT); pinMode(boton2, INPUT); pinMode(LED, OUTPUT); pinMode(LED_BUILTIN, OUTPUT); } void loop() { //Boton 1 val1 = digitalRead(boton1); if (val1 && !anterior1){ estado = true; n++; Serial.print(estado); Serial.print(", "); Serial.println(n); } anterior1 = val1; //Boton 2 val2 = digitalRead(boton2); if (val2 && !anterior2){ estado = false; n=0; Serial.print(estado); Serial.print(", "); Serial.println(n); } anterior2 = val2; //Pulsaste 3 veces seguidas boton 1 if (n == 3){ t = millis(); parar = true; n = 0; } //Bloquea 15 segundos if (millis()-t < 15000 && parar){ estado = false; digitalWrite(LED_BUILTIN, HIGH); }else{ parar = false; digitalWrite(LED_BUILTIN, LOW); } //Maneja LED if (estado){ digitalWrite(LED, HIGH); }else{ digitalWrite(LED, LOW); } } </syntaxhighlight> == Ejemplo 5 == En este ejemplo conectamos un display 7 segmentos entre los pines digitales 2 al 8 (segmentos a-f) cada uno con su resistencia de 330 ohmos. Luego mostramos alternativamente cada letra de HOLA de manera secuencial. <syntaxhighlight lang="c++"> const byte hola[]= {B1110110,B0111111,B0111000,B1110111}; //HOLA void setup() { for (byte n=2; n<9; n++){ pinMode(n, OUTPUT); } } void loop(){ for (byte i=0; i<4; i++){ for (byte s=2; s<9; s++){ digitalWrite(s, bitRead(hola[i], s-2)); } delay(1000); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones pines</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/variables/constants/constants/ Niveles lógicos en Arduino] * [https://playground.arduino.cc/ArduinoNotebookTraduccion/DigitalIO Playground] * [https://programarfacil.com/podcast/26-arduino-entradas-y-salidas/ Entradas y salidas] - Luis del Valle * [http://manueldelgadocrespo.blogspot.com/p/digitalwrite.html digitalWrite()] de Manuel Delgado * [https://aprendiendoarduino.wordpress.com/tag/digitalwrite/ digitalWrite] de Enrique Crespo * [https://blog.bricogeek.com/noticias/arduino/arduino-funcion-digitalwrite-mas-rapida/ Funcion digitalWrite mas rapida] de BricoGeek [[Category:Funciones pines]] 1hu1s894rost13jodvf0atuja5xof4d 0 216 5039 5038 2019-09-27T00:25:11Z Kike GL 2 /* Ejemplo 2 */ wikitext text/x-wiki == Descripción == Divide la variable entre un valor y guarda el resultado en la misma variable {{Tip|Es lo mismo que variable <nowiki>=</nowiki> variable / valor}} == Sintaxis == <pre> variable /= valor; variable = variable / valor; </pre> == Parámetros == ;variable: Nombre de la variable a operar. Puede ser de cualquier tipo: [[char]], [[byte]], [[int]], [[long]], [[float]]. ;valor: Valor del mismo tipo que variable. == Retorno == Devuelve la operación de división en la misma variable. == Advertencias == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> byte n = 12; n /= 2; //6 n /= 2; //3 </syntaxhighlight> == Ejemplo 2 == Este ejemplo muestra el numero 100 y luego divide entre 2 en cinco ocaciones (50, 25, 12, 6, 3). Nota que en la 3ra oportunidad hay un redondeo gracias a que la variable solo soporta números enteros. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); int numero = 100; Serial.println(numero); for (byte n=0; n<5; n++){ numero /= 2; Serial.println(numero); } } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias == [[Category:Operador aritmetico compuesto]] 66ewvqm66erjdqztd4gqobotymnu4nu 0 94 5033 4722 2019-09-27T00:20:19Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == La división es una de las cuatro operaciones aritméticas primarias. El operador /(barra inclinada) opera en dos operandos para producir el resultado. == Sintaxis == <pre> variable = valor / expresion; </pre> == Advertencias == * Al hacer operaciones aritméticas preste atención a los tipo de dato involucrados. * Por lógica, si la variable donde se almacenará el resultado no tiene signo, este jamás será negativo aunque uno de los operandos sea negativo. * La división entre enteros nunca produce fracciones, ni siquiera almacenando su resultado en un [[float]] o [[double]]. Para forzar la preservación de las cifras decimales, uno de los operandos debe ser (o convertirse a) un punto flotante. * La división por cero no es motivo para "colgar" la ejecución de un programa; sin embargo el resultado es indeterminado. Experimentando con la arquitectura AVR, se descubrió que la división por cero de enteros tiene como resultado todos los bits de la variable en 1; pero por alguna razón las funciones [[Serial|print()]] imprimen dicho resultado como el valor máximo de [[unsigned long]] ("4294967295"); a pesar de que la variable sea de tipo [[byte]], con signo (en este caso debería ser siempre -1), y se haya comprobado que si es un tipo menor a [[unsigned long]], nunca se sobrescriben 4 bytes en memoria. * La división por cero entre puntos flotantes ([[float]] o [[double]]) resulta en un valor llamado "infinito" (inf); se presume que se debe a la misma forma que se manejaría entre enteros. == Ejemplo == <pre> int x = 20; int y = 5; x = x/2; //10 x /= y; //2 (Divide x entre y) float f = 5 / 2; // Según una de las advertencias, el resultado sería 2.0 (no se preservaron las cifras decimales) f = 5.0 / 2; // Ya que uno de los operandos es un punto flotante, el resultado ahora sí sería 2.5 f = float(x) / 3; // Al convertir una variable entera a un punto flotante, los decimales también se preservan // En este punto de la ejecución, f valdría 0.6666667 </pre> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/structure/arithmetic-operators/division/ Guia de referencia de Arduino] * [https://aprendiendoarduino.wordpress.com/2018/04/08/operadores-5/ Aprendiendo Arduino] [[Category:Operador aritmetico]] 3dtivd1i4vflr6vzucdeho2wyea9em5 0 87 4183 4170 2019-06-11T21:07:02Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == El bucle '''do... while''' funciona de la misma manera que el bucle [[while]], con la excepción de que la condición se comprueba al final del bucle, por lo que el bucle se ejecutará siempre al menos una vez. == Sintaxis == <pre> do{ }while (condicion) </pre> == Parametros == ;condicion: expresión que debe ser evaluada como verdadera para repetir el bucle. == Comentarios == * Normalmente se usa cuando de ante mano no sabes el numero de interacciones que requieres y le dejas a alguna variable la desicion. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> byte x = 0; do { //Repite algo 100 veces x++; } while (x < 100); </syntaxhighlight> == Vea también == <categorytree mode=all>Estructura control</categorytree> == Referencias externas == * [http://arduino.cc/en/Reference/DoWhile Guia de referencia de Arduino] * [https://aprendiendoarduino.wordpress.com/tag/estructuras-de-control/ Estructura de control] - Enrique Crespo * [http://manueldelgadocrespo.blogspot.com/p/bucle-dowhile.html El bucle do while] - Manuel Delgado [[Category:Estructura control]] 085l7chl2ke01ha0ewxzpgpl51h8pid 0 198 3682 3681 2019-05-06T18:41:34Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Número de punto flotante de doble precisión (respecto a [[float]]). == Sintaxis == <pre> double variable [= valor]; </pre> == Parámetros == ;variable: variable a definir ;valor: valor a asignar == Advertencias == * En Arduinos con ATmega (AVR en general), '''double''' ocupa 4 bytes (32 bits); por lo que es igual a [[float]] y no hay ganancia en precisión. * En Arduino [[DUE]], '''double''' ocupa 8 bytes (64 bits); por lo tanto sí mejora la precisión. == Ejemplo 1 == <pre> double areaCirculo = PI * sq(r); // Pi * r^2, r: radio del círculo double pruebaDecimales = 1.234567890123456789; // ¿Podrá almacenar tantos dígitos decimales? </pre> == Ejemplo 2 == Si tienes un [[float]] o un '''double''' puedes especificar el numero de decimales. <syntaxhighlight lang="c++"> Serial.print(PI, 2); //3.14 Serial.println(PI, 6); //3.141593 </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == [[Category:Tipo dato]] fiatkhsbi5y88xxnbemvc51y7i3i8kj 0 499 5201 5095 2020-02-02T04:29:16Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Palabra clave conocida como '''calificadora'''. Se usa antes del tipo de datos de una variable, para modificar la manera en que el compilador y el [[boceto]] deben tratar dicha variable. La declaración de una variable '''extern''' es una directiva del compilador. El compilador es un software que traduce el código Arduino en el código de máquina, que son las instrucciones reales para el chip ATmel en el Arduino. {{Nota|Una variable debe ser declarada '''extern''' cada vez que no es definida en el mismo [[boceto]] a fin de que el compiladr no arrroje el error variable no encontrada.}} == Sintaxis == <pre> extern tipo variable [= valor]; extern variable [= Pvalor]; </pre> == Parámetros == ;tipo: define el tipo de variable. [[char]], [[byte]], [[int]], [[long]], [[float]], etc {| class="wikitable col2cen" |+Subfijos !Tipo!!Subfijo!!Ejemplo |- |[[int]]||ninguno||123 |- |[[unsigned int]]||U||123U |- |[[long]]||L||123L |- |[[unsigned long]]||UL||123UL |- |[[float]]||F||1.23F |} ;variable:nombre de la variable. ;valor:valor a almacenar en el rango del tipo de dato. ;Pvalor:valor a almacenar en el rango del tipo de dato con prefijo de formateo. {| class="wikitable col2cen" |+Prefijos !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1110011 |} == Advertencias == * Cuando declaras una variable en un archivo .cpp para que esta sea accesible desde el archivo .ino <pre> #include archivo.h void setup(){ Serial.begin(9600); Serial.print(variable); } void loop(){ //Nada } </pre> == Ejemplo 1 == <syntaxhighlight lang="c++"> extern n = 123 //int extern n = 123U //unsigned int extern n = 123L //long extern n = 123UL //unsigned long extern n = 1.23F //float extern byte n = 123; extern byte n = B1110011; extern byte n = 0173; extern byte n = 0x7B; </syntaxhighlight> == Ejemplo 2 == Conmuta el LED a bordo cuando se pulsa botón. Conectar pulsador entre pin 7 y GND. <syntaxhighlight lang="c++"> volatile bool estado = LOW; void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(7, INPUT_PULLUP); attachInterrupt(0, cambia, CHANGE); } void cambia(){ estado = !estado; } void loop(){ digitalWrite(LED_BUILTIN, estado); } </syntaxhighlight> == Vea también == * [[variable publica]] * [[variable local]] * [[matriz]] * [[static]] * [[const]] * [[define|#define]] * [[Palabras reservadas]] * [[Comentarios]] - <nowiki>(//)</nowiki> == Referencias externas == [[Category:Variables]] rxwksexiymybifs3xx1qyrjpgwr5zd0 0 333 3769 3763 2019-05-06T22:25:45Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == Es la memoria de programa donde esta el bootloader y se almacenan los [[boceto|bocetos]] ya compilados. Se mantiene aun si apagamos nuestro Arduino. Usualmente entre 1~4 Mb. Es el equivalente al disco duro de un computador. Se puede ejecutar un programa desde la memoria flash, pero no es posible modificar los datos, sino que es necesario copiar los datos en la [[SRAM]] para codificarlos. Esta memoria usa la misma tecnología que las memorias USB (pendrive), tarjetas SD y algunos discos de estado solido. Esta memoria tiene una vida útil de unos 100,000 ciclos de escritura, así que cargando 10 programas al día durante 30 años podrías dañar la memoria flash de tu Arduino. Ademas desde la versión 1.0 del [[IDE]] de Arduino, se introdujo la macro [[F()]]. Esta sintaxis se usa para almacenar cadenas en la memoria [[flash]] en lugar de en la [[SRAM]]. No es necesario cargar ninguna librería para usar la macro [[F()]]. {{Nota|Recuerda que al incluir una librería, estas añadiendo programas y variables, lo que aumentará el uso de memoria [[flash]] y [[SRAM]]. Algunas librerías hacen un uso intensivo de la memoria '''flash''' y [[SRAM]].}} {|class="wikitable col2cen col3cen col4cen" |+Memoria en cada Arduino !Tipo!!Arduino [[UNO]]!!Arduino [[MEGA]]!!Arduino [[MKR1000]] |- |[[flash]]||32K||256K||256K |- |Flash-bootloader||0.5K||8K||- |- |[[SRAM]]||2K||8K||32K |- |[[EEPROM]]||1K||4K||- |} == Advertencias == En el caso que el [[boceto]] ocupe más memoria '''flash''', el [[IDE]] te avisa de que no puede cargarlo en Arduino. Cada vez que compilas un boceto el [[IDE]] de Arduino te informa de la memoria flash que ocupa el programa y la RAM ocupada por las variables globales y el espacio que queda para las variables locales. Como recomendación, si se supera el 70~75% de la [[SRAM]] con las variables globales es muy probable que Arduino se quede sin memoria [[SRAM]] para trabajar. == Ejemplo == <syntaxhighlight lang="c++"> Serial.println("Esta cadena se almacena en memoria SRAM"); //Usa 42 bytes de memoria SRAM Serial.println(F("Esta cadena se almacenada en memoria flash")); </syntaxhighlight> == Vea también == <categorytree mode=all>memoria</categorytree> == Referencias == [[Category:memoria]] rriyg13d4hgtnpz58r2zoezwf39wnz9 0 65 5230 5229 2020-02-02T18:45:35Z Kike GL 2 /* Ejemplo 2 */ wikitext text/x-wiki == Descripción == El formato numérico de 4 bytes (32 bits), son números de '''punto flotante''' osea con decimales. Están comprendidos entre -3.4E38 y +3.4E38. Este tipo de números se usan a menudo para aproximar los valores analógicos y continuos porque tienen mayor resolución que los números enteros. {{Nota|Si hacemos operaciones matemáticas con '''float''', es necesario agregar un punto decimal, de lo contrario, será tratado como un int.}} Los 32 bits esta distribuidos asi: * EL primer bit es el signo (1 = negativo) * Los 8 siguientes son la parte entera. * Los 23 restantes son los decimales. == Sintaxis == <pre> float variable [= valor]; variable = valorF; </pre> == Parametros == ;variable: Nombre de variable a definir. ;valor: El valor asignado a la variable que debe contener un punto. ;valorF: Forzar tipo con subfijo '''F'''. Puedes omitir la palabra float antes de nombre de variable. {| class="wikitable col2cen" |+Posibles formateadores !Base!!Subfijo!!Ejemplo |- |[[unsigned int]]||U||n = 123U |- |[[long]]||L||n = 123L |- |[[unsigned long]]||UL||n = 123UL |- |[[float]]||F||n =12.3F |} == Comentarios == Las constantes de punto flotante también se pueden expresar en una variedad de notación científica. 'E' y 'e' son aceptados como indicadores de exponente válidos. == Advertencias == * Los '''float''' tienen sólo 6-7 dígitos decimales de precisión. Eso significa que el número total de dígitos, no es el número a la derecha del punto decimal. * Los números de punto flotante '''no son exactos''' y pueden producir resultados extraños si se comparan. Por ejemplo 6.0 / 3.0 puede no ser igual 2.0. En su lugar debe comprobar que el valor absoluto de la diferencia entre el número es menor que un número pequeño. * A diferencia de otras plataformas, donde se puede obtener una mayor precisión mediante el uso de un [[double]] (por ejemplo, hasta 15 dígitos), en el Arduino, el [[double]] es del '''mismo tamaño que el float'''. * Las operaciones matemáticas de punto flotante también son '''mucho más lenta''' que las operaciones matemáticas con enteros en los cálculos que realizan, por lo que deben evitarse si, por ejemplo, un bucle tiene que correr a gran velocidad para una función crítica de sincronización. Los programadores suelen convertir los cálculos de punto flotante a entero para aumentar la velocidad. == Ejemplo 1 == Asignaciones directas. <syntaxhighlight lang="c++"> x = 1.23F; float n = 2.32; float z = 2.34E-5 //0.0000234 </syntaxhighlight> == Ejemplo 2 == Operaciones con numeros. 8/2 es un [[int]]. para que sea '''float''' debe ser 8.0/2, 8/2.0 o 8.0/2.0 <syntaxhighlight lang="c++"> int x = n/2 //1 float y = n/2 //1 float y = n/2.0 //1.16 float n = 8.0/2.0; //Entre 1.99 y 2.01 </syntaxhighlight> == Ejemplo 3 == Dividir 100/1024 y luego multiplicarlo nuevamente por 100 no da lo mismo. <syntaxhighlight lang="c++"> float n = 100.0/1024.0; n = 100.0 * n //No es lo mismo float n = 100.0 * 1024.0; n = n / 100.0 //Es lo mismo </syntaxhighlight> == Ejemplo 4 == Si tienes un '''float''' o un [[double]] puedes especificar el numero de decimales. <syntaxhighlight lang="c++"> Serial.print(PI, 2); //3.14 Serial.println(PI, 6); //3.141593 </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/float/ Guia de referencia de Arduino] * [https://playground.arduino.cc/ArduinoNotebookTraduccion/Datatypes Playground] * [https://manueldelgadocrespo.blogspot.com/p/float.html Arduino en español] - Manuel Delgado * [https://aprendiendoarduino.wordpress.com/2015/03/26/tipos-de-datos/ Aprendiendo Arduino] - Enrique Crespo * [http://rufianenlared.com/float/ Float, eres problematico y Arduino lo sabe] - Rufian en la red [[Category:Tipo dato]] 4nbu4dmla7bh8vr1v05aievx91wxfcy 0 178 4827 4826 2019-07-19T00:46:37Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Convierte un valor numérico de cualquier tipo a [[float]]. == Sintaxis == <pre> float(variable); </pre> == Parametros == ;variable: variable de cualquier tipo a evaluar. [[char]], [[byte]], [[int]], [[long]], [[double]]. == Retorna == Retorna un numero tipo [[float]]. == Advertencias == No funciona con cadenas [[string]] ni objetos [[String]]. == Ejemplo == <syntaxhighlight lang="c++"> char a = 'A'; byte b = 123; int c = -12345; void setup(){ Serial.begin(9600); byte valor1 = byte(a); Serial.println(valor1); int valor2 = long(b); Serial.println(valor2); unsigned int valor3 = word(b); Serial.println(valor3); long valor4 = long(b); Serial.println(valor4); float valor5 = float(c); Serial.println(valor5); } void loop(){ //Nada. } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/en/language/variables/data-types/float/ Guia de referencia de Arduino] * [http://rufianenlared.com/float/ Float, eres problematico y Arduino lo sabe] - Rufian de la Red [[Category:Funciones conversion]] 1t1nbhtv4cdscrwyvqtne0vk8g8c2cd 0 174 4287 4210 2019-06-11T23:33:49Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Redondea un numero tipo [[float]] hacia abajo. == Sintaxis == <pre> floor(valor); floor(variable); </pre> == Parámetros == ;valor: valor tipo [[float]] a operar. ;variable: nombre de variable tipo [[float]] a operar. == Retorno == Retorna un numero tipo [[long]]. == Advertencias == Nada. == Ejemplo == <pre> floor(PI); //3 </pre> == Vea también == <categorytree mode=all>Funciones matematicas</categorytree> == Referencias externas == [[Category:Funciones matematicas]] f8jwbsdeuai6s6yl29a0otlc0a4bbkr 0 60 5287 5258 2020-06-06T21:29:35Z Kike GL 2 /* Ejemplo 4 */ wikitext text/x-wiki == Descripción == La declaración '''for''' se usa para repetir un bloque de sentencias encerradas entre llaves un número determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a comprobar la condición. {{Nota|Se usa para cuando tu sabes de antemano cuantas veces debes repetir el bucle.}} == Sintaxis == <pre> for (declaracion-initialization; condicion; incremento) { //instrucción(es); } </pre> == Parametros == ;declaracion-initialization: declaración e inicialización de variables a utilizar en el ciclo. ;condicion: condicional que debe cumplir desde el principio ;incremento: incremento o decremento. Son un conjunto de instrucciones (separadas por coma ''',''' ) que se ejecutan cada vez que se completa una iteración del ciclo. A diferencia de la condición, esta parte nunca ocurre la primera vez. {{Nota|Todos los parámetros se pueden omitir (sin embargo los dos ''';''' siguen siendo obligatorios), pero si se omite la condición, esta siempre se asumirá verdadera; lo que resultaría en un bucle infinito hasta encontrarse con una sentencia [[break]].}} == Advertencias == Nada. == Ejemplo 1 == En este ejemplo conectamos un LED en un pin digital PWM y hacemos variar iluminacion con [[analogWrite()]]. <syntaxhighlight lang="c++"> const byte pin = 10; //LED void setup() { pinMode(pin, OUTPUT); } void loop(){ for (byte i=0; i<=255; i++){ analogWrite(pin, i); //PWM delay(100); } } </syntaxhighlight> == Ejemplo 2 == Revisa este curioso ejemplo donde no hay el 3er termino en el for() que normalmente incrementa la variable. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); for (unsigned long start=millis(); millis()-start<1000;){ Serial.println(start); } } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 3 == En este ejemplo es el [[break]] quien termina el ciclo for. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); for (byte n=0; n<254; n++){ Seral.println(n); if (n>10){ break; } } } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 4 == Error de novato. Como ya sabes [[byte]] soporta valores entre 0 y 255. Asi que '''siempre''' se cumplira la condicion n<256 y este for nunca terminara. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); for (byte n=0; n<256; n++){ Seral.println(n); } } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 5 == En matemáticas, la sucesión o serie de '''Fibonacci''' es la siguiente sucesión infinita de números naturales: 0,1,1,2,3,5,8,13,21,34,55,89,144.. <syntaxhighlight lang="c++"> byte s[13] ; void setup(){ Serial.begin(9600); for (byte n=0; n<13; n++) { if (n==0 || n==1) { s[0]=0; s[1]=1; }else{ s[n] = s[n-1]+s[n-2]; } Serial.println(s[n]); } } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Estructura control</categorytree> == Referencias externas == * [http://arduino.cc/en/Reference/For Guia de referencia de Arduino] * [https://aprendiendoarduino.wordpress.com/tag/estructuras-de-control/ Estructuras de control] - Enrique Crespo [[Category:Estructura control]] n4jrrnzprf8efbvraz4xfuqi5xc7j36 0 367 2030 2026 2018-07-15T13:36:14Z Kike GL 2 Kike GL trasladó la página [[free]] a [[free()]] sin dejar una redirección wikitext text/x-wiki == Descripción == Desasignar bloque de memoria. Un bloque de memoria asignado previamente por una llamada a [[malloc()]], [[calloc()]] o [[realloc()]] está desasignado, volviendo a estar disponible para otras asignaciones. == Sintaxis == <pre> free(ptr); </pre> == Parámetros == ;ptr: Puntero a un bloque de memoria previamente asignado con [[malloc()]], [[calloc()]] o [[realloc()]]. == Retorno == Nada == Comentarios == * Solo se modifica el almacenamiento al que se hace referencia por ptr. * No se accede a ninguna otra ubicación de almacenamiento mediante la llamada. * Si la función libera una unidad de almacenamiento que se reutiliza mediante una llamada a funciones de asignación (como [[calloc()]] o [[malloc()]], las funciones se sincronizan de tal manera que la desasignación ocurre completamente antes de la siguiente asignación. == Advertencias == * Si ptr no apunta a un bloque de memoria asignado con las funciones [[malloc()]], [[calloc()]] o [[realloc()]], causa un comportamiento indefinido. * Si ptr es un puntero nulo, la función no hace nada. * Tenga en cuenta que esta función no cambia el valor de ptr en sí, por lo tanto, todavía apunta a la misma ubicación (ahora no válida). == Ejemplo == <pre> void funcion(){ int * buffer1, * buffer2, * buffer3; buffer1 = (int*) malloc(100* sizeof(int)); buffer2 = (int*) calloc(100, sizeof(int)); buffer3 = (int*) realloc(buffer2, 500*sizeof(int)); free (buffer1); free (buffer3); } </pre> == Vea también == * [[malloc()]] * [[calloc()]] * [[realloc()]] == Referencias == * [http://www.cplusplus.com/reference/cstdlib/free Cplusplus] [[Category:Funciones]] j16z02vg8f6l3zuzg42qprwefwq66q7 0 88 4561 4199 2019-06-27T01:25:58Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Transfiere el flujo del programa a un punto etiquetado en el programa == Sintaxis == <pre> goto etiqueta; </pre> == Parametros == ;Etiqueta: Marca de llegada de goto. Palabra terminada en ''':''' == Advertencias == * El uso de '''goto''' se desaconseja en la programación C++ ya que no es necesaria, pero si se usa juiciosamente, se pueden simplificar ciertos programas. * La razón por la que muchos programadores desaprueban el uso de goto es que con el uso incontrolado de sentencias goto, es fácil para crear un programa con el flujo del programa no definido, muy difícil de depurar. * Dicho esto, hay casos en que una instrucción goto puede venir bien y simplificar la codificación. Una de estas situaciones es para salir de anidado de los bucles, o de los bloques lógicos if, en una determinada condición. == Ejemplo == <syntaxhighlight lang="c++"> for (byte g=255; g>-1; g--){ for (byte b = 0; b < 255; b++){ if (analogRead(0) > 250){ goto rescate; } //más instrucciones ... } } rescate: //más instrucciones ... </syntaxhighlight> == Vea también == <categorytree mode=all>Estructura control</categorytree> == Referencias externa== * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Estructura control]] fb8jzn8s5fqjd6kwh17upgk4msdtktn 0 195 4698 4320 2019-07-14T17:40:36Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Extrae el byte de orden superior (MSB) en [[int]] o el segundo byte más bajo de un tipo de datos más grande como [[long]]. == Sintaxis == <pre> highByte(variable); </pre> == Parámetros == ;variable: variable a evaluar que deberá ser [[int]], [[long]], [[float]], [[unsigned int]] o [[unsigned long]] == Retornos == Retorna byte mas significativo. == Advertencias == Cuidado al trabajar con tipo [[long]] que es de 4 bytes, porque highByte() se refiere al que esta a la izquierda del LSB y no se refiere al MSB. <pre> long val = 0x11223344; highByte(val); //33 lowByte(val); //44 (LSB) </pre> == Ejemplo 1 == Descomponer en [[byte]]s y reconstruir un [[int]]. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); //Descomponer int dat1 = 12345; Serial.println(dat1, HEX); //0x3039 byte val1 = highByte(dat1); //0x30 (MSB) byte val2 = lowByte(dat1); //0x39 (LSB) Serial.println("-------"); //Reconstruir int dat2; dat2 = val1; //Tomamos MSB dat2 <<= 8; //Desplazamos 8 bits a la izquierda dat2 |= val2; //Añadimos LSB Serial.println(dat2, HEX); //0x3039 } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == Descomponer en [[byte]]s y reconstruir un [[long]]. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); //Descomponer long dat1 = 123456789; Serial.println(dat1, HEX); byte val[4]; for (byte i=0; i<4; i++) { val[i] = lowByte(dat1); Serial.println(val[i], HEX); dat1 >>= 8; //desplazar aqui } Serial.println("-------"); //Reconstruir long dat2; for (byte i=0; i<4; i++) { dat2 |= val[3-i]; //Meter en LSB if (i 3){ //Menor que 3 dat2 <<= 8; //desplazar aqui } } Serial.println(dat2); } void loop(){ //Nada } ********* Ejemplo incompleto no permite ******* </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones bit y byte</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones bit y byte]] 2l655ahnek5bci0cjl1ga1i3eopj4vb 0 55 4560 4367 2019-06-27T01:23:44Z Kike GL 2 /* Ejemplo 4 */ wikitext text/x-wiki == Descripción == El condicional '''if()''' permite un mayor control del flujo de código al permitir ejecutar o no un grupo de instrucciones según el resultado de una condición. {{Tip|También llamado condicional simple.}} Además se puede usar '''else''' dentro de las llaves de modo que, si la condición es falsa, se ejecute un segundo juego de códigos. También se puede anidar condicionales simples con else if(), de manera que se pueden establecer varias estructuras condicionales anidadas de forma que sean mutuamente excluyentes. Recuerde sin embargo qué sólo un conjunto de declaraciones se llevará a cabo dependiendo de las condiciones impuestas. {{Nota|Tenga en cuenta que un bloque '''if()''' se puede usar con o sin un bloque '''else''' y viceversa. Se permite un número ilimitado de ramificaciones usando '''else if()'''.}} == Sintaxis == Condicional simple <pre> if (condicion) { //Ejecuta si condición es verdadera } </pre> Condicional compuesta <pre> if (condicion) { //Ejecuta si condición es verdadera }else{ //Ejecuta si condición es falsa } </pre> Condicionales anidadas <pre> if (condicion 1) { //Ejecuta si condición 1 es verdadera }else if (condicion 2){ //Ejecuta si condición 1 es falsa y condicional 2 es falsa }else{ //Ejecuta si ambas condiciónes son falsa } </pre> == Parámetros == ;condición: es una expresión que se evalúa como verdadera o falsa. == Comentarios == * Si se omiten las llaves solo se ejecuta una instrucción. * Si tienes una función que de por si da como resultado true/false la puedes usar directamente sin evaluar. Eso implica que es lo mismo poner digitalRead(13) que digitalRead(13) == true. * Recuerda que true es lo mismo que HIGH o 1 y false es lo mismo que LOW o 0. {{Nota|Se puede poner varias expresiones unidas por los operadores lógicos [[or]] o [[and]].}} == Advertencias == * No confundir el comparador de [[igualdad]] (<nowiki>==</nowiki>) con el operador de [[asignacion]] (<nowiki>=</nowiki>). == Ejemplo 1 == Se puede comprobar una entrada analógica y realizar una acción si el valor de la entrada es menor que 500 y realizar otra acción distinta si la entrada es 500 o mayor. <syntaxhighlight lang="c++"> if (analogRead(A3) < 500) { //acción A }else{ //acción B } </syntaxhighlight> == Ejemplo 2 == Aquí usamos dos comparaciones con distintas expresiones. <syntaxhighlight lang="c++"> if (analogRead(A3) < 500){ //instrucciones A }else if (digitalRead(LED_BUILTIN)){ //instrucciones B }else{ //instrucciones C } </syntaxhighlight> == Ejemplo 3 == Con este código producimos un parpadeo. <syntaxhighlight lang="c++"> void setup(){ pinMode(LED_BUILTIN, OUTPUT); } void loop(){ if (digitalRead(LED_BUILTIN)){ digitalWrite(LED_BUILTIN, LOW) //Apaga LED }else{ digitalWrite(LED_BUILTIN, HIGH) //Prende LED } delay(500); } </syntaxhighlight> {{Tip|No es necesario poner if (digitalRead(LED_BUILTIN) <nowiki>==</nowiki> HIGH).}} == Ejemplo 4 == Podemos usar una condicional simple dentro de [[Serial.print()]] o [[Serial.println()]] <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); for (byte n=2; n<14; n++){ pinMode(n, INPUT); } } void loop(){ for (byte n=2; n<14; n++){ Serial.print(n); Serial.print(" = "); Serial.println(digitalRead(n)?"Prendido":"Apagado"); } Serial.println("---------"); delay(1000); } </syntaxhighlight> == Ejemplo 5 == En este ejemplo no cambiamos el valor del PWM entre 86~126. Nota que al definir la variable tipo [[byte]] luego del 255 el siguiente numero es 0 nuevamente. <syntaxhighlight lang="c++"> byte n; void setup(){ pinMode(LED_BUILTIN, OUTPUT); } void loop(){ n++; if (n>85 && n<169){ analogWrite(LED_BUILTIN, 127); }else{ analogWrite(LED_BUILTIN, n); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Estructura control</categorytree> == Referencias == * [http://arduino.cc/en/Reference/If Guia de referencia de Arduino] * [https://programarfacil.com/blog/arduino-blog/if-else-arduino/ if el Arduino] - Programar Facil * [https://aprendiendoarduino.wordpress.com/2017/10/14/estructuras-de-control-4/ Estructuras de control] - Enrique Crespo [[Category:Estructura control]] f83n5brlnhrbitnqv5mdb1rbpak6rnh 0 99 5002 5001 2019-09-26T23:42:06Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Se llama operador de igualdad a un único signo igual doble. == Sintaxis == <pre> [tipo] variable == valor; [tipo] variable == expresion; [tipo] variable == variable1; </pre> == Parámetros == ;tipo:Tipo de dato Arduino a almacenas en la variable. Opcional, solo se usa la primera vez. ;variable:Nombre de la variable a asignar. ;valor:Valor a asignar a la variable ;expresion:Formula con operadores aritméticos incluidos (+, -, *, /, %) ;variable1:Otra variable del mismo tipo. {|class="wikitable" |+Tipos de dato en Arduino !Tipo!!Ocupa!!Rango |- |[[char]]||1 byte (8 bits)||-128 a 127 |- |[[byte]]||1 byte (8 bits)||0 a 255 |- |[[int]]||2 byte (16 bits)||-32,768 a 32,767 |- |[[unsigned int]] o [[word]]||2 byte (16 bits)||0 a 65,535 |- |[[long]]||4 byte (32 bits)||-2,147,483,648 a 2,147,483,647 |- |[[unsigned long]]||4 byte (32 bits)||0 a 4,294,967,295 |- |[[float]]||4 byte (32 bits)||-3.4E38 a 3.4E38 |} {| class="wikitable col2cen" |+Posibles formateadores !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1111011 |- |BIN||0b||0 o 1, funciona para más de 8 bits||0b1111011 |} == Retorna == Verdadero si son iguales y falso si no lo son. == Advertencias == * No confunda el operador de asignación = (signo igual individual) con el operador de comparación == (doble signos igual), que evalúa si los dos expresiones son iguales. == Ejemplo == <syntaxhighlight lang="c++"> if (x == 9){ //Es igual }else{ //Es diferente } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador comparador</categorytree> <categorytree mode=all>Operador logico</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Operador comparador]] qcl8nqc2fms5zr8wgoqqqpdc84ecm35 0 204 5240 5239 2020-02-02T18:59:15Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Se usa para incluir librerías externas en tu [[boceto]]. Esto le da al [[boceto]] de Arduino acceso a un gran grupo de librerías Arduino estándar prefabricadas que traen nuevos métodos y funciones. El nombre de la librería deberá estar entre &lt; y &gt;. {{Nota|No debe poner terminador de punto y coma o el compilador dará un error.}} == Sintaxis == <pre> #include <libreria.h> #include "libreria.h" </pre> == Parametros == ;<>:Es un archivo de libreria externa ;"":Es un archivo del proyecto == Retorno == Nada. == Comentarios == * También se puede usar '''#include''' para incluir archivos .ino el [[IDE]] junta todos los archivo .ino en un archivo temporal y luego compila. Así no da errores de variables no encontradas "was not declared in this scope". == Advertencia == Tenga en cuenta que '''#include''', similarmente a #[[define]], no tiene un terminador de punto y coma, y el compilador dará lugar a mensajes de error si se agrega una. == Ejemplos == En este ejemplo hay un solo pulsador en pin 2. <syntaxhighlight lang="c++"> #include <Bounce2.h> Bounce rebote = Bounce(); //Instancia objeto void setup() { pinMode(2, INPUT_PULLUP); rebote.attach(2); //Cuando ya esta definido el pin rebote.interval(5); pinMode(13, OUTPUT); } void loop() { rebote.update(); //Actualiza if (rebote.read()) { digitalWrite(13, digitalReac(13)); //Conmuta LED } } </syntaxhighlight> == Vea también == * [[Comentarios]] <nowiki>(//)</nowiki> * [[define|#define]] * [[const]] == Referencias == * [https://www.arduino.cc/reference/en/language/structure/further-syntax/include/ include] - Arduino * [https://aprendiendoarduino.wordpress.com/2016/11/16/librerias-arduino-2/ librerias] - Enrique Crespo * [http://manueldelgadocrespo.blogspot.com/p/include.html Include] - Manuel Delgado * [https://www.prometec.net/intro-programacion/ Introduccion a la programacion] - Prometec [[Category:Estructura]] epu3execczb2qald0oup7zk2wcd9zml 0 211 5032 4724 2019-09-27T00:19:44Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Incremente la variable en una unidad. {{Nota|Es lo mismo que variable <nowiki>=</nowiki> variable + 1.}} == Sintaxis == <pre> variable++; ++variable; variable = variable + 1; </pre> == Parámetros == ;variable: Nombre de la variable a operar. Puede ser de cualquier tipo: [[char]], [[byte]], [[int]], [[long]], [[float]]. ;valor: Valor del mismo tipo que variable. == Retorno == Valor de la variable aumentado en uno. == Advertencias == * El riesgo del desbordamiento (ir más allá de lo que una variable puede almacenar, su rango de valores) sigue estando presente. En este caso sería volver a cero o pasar a un número negativo. == Ejemplo 1 == Desbordamos el [[byte]]. <syntaxhighlight lang="c++"> byte n = 254; n++; //255 n++; //0 n++; //1 </syntaxhighlight> == Ejemplo 2 == Nota la diferencia de poner delante o detras. <syntaxhighlight lang="c++"> byte x = 2; y = ++n; //x=3 y=3 y = n++; //x=4 y=3 </syntaxhighlight> == Ejemplo 3 == Es muy comun usarlo en un [[for]] para cuenta ascendente. <syntaxhighlight lang="c++"> for (byte n=0; n<5; n++){ //Repite 5 veces } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias == [[Category:Operador aritmetico]] fwhg4b31hl78i25cxoewcbddav2j8mh 0 63 5153 5152 2020-01-24T16:33:34Z Kike GL 2 /* Sintaxis */ wikitext text/x-wiki == Descripción == Los '''int''' (enteros) son el tipo de datos primario para el almacenamiento de números. En el Arduino [[UNO]] (y otras placa basadas en el ATmega) un '''int''' almacena un valor de 2 byte (16 bit). Esto produce un rango de -32,768 (-2^15) a 32,767 (2^15-1). En el Arduino [[DUE]], un '''int''' almacena un valor de 4 byte (32 bit). Esto produce un rango de -2,147,483,648 (-2^31) a 2,147,483,647 (2^31-1). Los '''int''' almacenan números negativos con una técnica llamada complemento matemático a 2. El bit más alto, a veces llamado bit de "signo" es la bandera que define el número como negativo. El resto de los bits se invierte y se les añade 1. == Sintaxis == <pre> int variable [= valor]; int16_t variable [= valor]; //Solo UNO int32_t variable [= valor]; //Solo MEGA </pre> == Parámetros == ;variable: nombre de a variable a definir. ;valor: numero en el rango. Parámetro opcional. {| class="wikitable col2cen" |+Posibles formateadores !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1111011 |} == Comentarios == * En Arduino [[MEGA]] es un tipo de 2 bytes (16 bits) que almacena numeros entre -32,768 (-2^15) y 32,767 (2^15-1). * Los números negativos se almacenan con una técnica llamada '''matemática del complemento a 2'''. El bit más alto, a veces denominado bit de "signo", marca el número como un número negativo. El resto de los bits se invierten y se agrega 1. == Advertencias == * El Arduino se encarga de tratar los número negativos por nosotros, por lo que las operaciones aritméticas trabajan de forma transparente de la manera esperada. Sin embargo, podemos encontrarnos con una complicación inesperada con el operador [[bitshift right]] (>>) (desplazamiento de bit a la derecha). * Si sumas 1 al valor maximo que de 32,767 pasa a -32,768. * Si restas 1 al valor minimo que de -32,768 pasa a 32,767. <syntaxhighlight lang="c++"> int a = 35767; a++; //-32,768 int b = -31768; b--; //32,767 </syntaxhighlight> == Ejemplo 1 == <syntaxhighlight lang="c++"> int num; //Variable declarada pero no inicializada. int x,y,z; //Multiple variable declaradas pero no inicializadas. int x=0,y=1,z=2; //Multiples variables declaradas e inicializadas. int n = 'A'; int n = 65; int n = 0x41; //0x = formato hexadecimal, 65 int n = 0101; //0 = formato octal, 65 int n = B1000001; //B = formato binario, 65 </syntaxhighlight> == Ejemplo 2 == En el siguiente ejemplo usuario pretende usar 4K de [[SRAM]] cuando Arduino [[UNO]] solo tiene 2K. <syntaxhighlight lang="c++"> int var[2000]; //Error </syntaxhighlight> == Ejemplo 3 == Asignamos un caracter ASCII al int y operamos. <syntaxhighlight lang="c++"> void setup() { Serial.begin(115000); Serial.println("Letras mayusculas:"); for (int c='A'; c<='Z'; c++){ Serial.write(c); //Imprime el carácter Serial.print(", dec: "); Serial.println(c); //Imprime su valor ASCII decimal delay(100); } } void loop() { //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/int/ Guia de referencia de Arduino] [[Category:Tipo dato]] enih9ed4q2p35lzn9mge5smy6krhzd3 0 176 4310 4226 2019-06-11T23:46:52Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Convierte un valor en un dato tipo [[int]]. == Sintaxis == <pre> int(variable); </pre> == Parámetros == ;variable: variable de cualquier tipo a evaluar. == Retorna == Retorna un numero tipo [[int]]. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> char a = 'A'; byte b = 123; void setup(){ Serial.begin(9600); byte valor1 = byte(a); Serial.println(valor1); int valor2 = long(b); Serial.println(valor2); unsigned int valor3 = word(b); Serial.println(valor3); long valor4 = long(b); Serial.println(valor4); } void loop(){ //Nada. } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> * [[atoi()]] * [[objeto.toInt()]] * [[objeto.toFloat()]] * [[objeto.getBytes()]] == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones conversion]] 0zhlh6hxrv4n489x4u1oxgpsgtlrhz5 0 42 4941 4260 2019-09-22T16:35:58Z Kike GL 2 /* Advertencias */ wikitext text/x-wiki == Descripción == Vuelve a habilitar las interrupciones (después de que han sido desactivadas por [[noInterrupts()]]. Las interrupciones permiten que ciertas tareas importantes que suceden en segundo plano sean activadas por defecto. == Sintaxis == <pre> interrupts(); cli(); </pre> == Parámetros == Nada. == Retornos == Nada. == Advertencias == * Algunas funciones no trabajarán mientras las interrupciones están deshabilitadas, y las comunicaciones entrantes pueden ser ignoradas. Las interrupciones pueden alterar ligeramente la sincronización de código, sin embargo, y pueden ser desactivadas de los sectores especialmente críticos del código. * No puedes usar [[Serial.print()]] dentro de una interrupcion. == Ejemplo == <syntaxhighlight lang="c++"> void setup() { //Nada } void loop(){ noInterrupts(); //Aquí el código sensible al tiempo interrupts(); //Aqui el resto del código } </syntaxhighlight> == Vea también == * [[attachInterrupt()]] * [[detachInterrupt()]] * [[noInterrupts()]] == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [https://www.luisllamas.es/que-son-y-como-usar-interrupciones-en-arduino/ Luis Llamas] * [http://www.gammon.com.au/interrupts Nick Gammon] [[Category:Funciones interrupciones]] 08wwhrnwcxazgjrde9nfjvc0et3glkt 0 84 4294 4218 2019-06-11T23:38:12Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si parámetro es una letra. a-z + A-Z. == Sintaxis == <pre> isAlpha(dato); isAlpha(variable); </pre> == Parametro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si la dato o variable es una letra del alfabeto o false si no lo es. == Advertencias == Nada. == Ejemplo 1 == <pre> isAlpha('a'); //verdadero isAlpha('M'); //verdadero isAlpha('3'); //falso isAlpha(' '); //falso isAlpha('%'); //falso </pre> == Ejemplo 2 == Envía un carácter desde el monitor serie y veras si es de este tipo o no. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte caracter = Serial.Read(); if (isAlpha(caracter)){ Serial.print("SI"); }else{ Serial.print("NO"); } Serial.println(" es Alpha"); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] jkixrapxci697wsk7grqae0bh6ak6hk 0 72 4295 4221 2019-06-11T23:38:28Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si variable es un carácter alfanumérico (número o letra). a-z + A-Z + 0-9. == Sintaxis == <pre> isAlphaNumeric(dato); isAlphaNumeric(variable); </pre> == Parametros == ;variable: nombre de variable a analizar. ;dato: carácter a evaluar entre comillas simples. == Retorno == Devuelve verdadero si la variable contiene un valor alfanumerico o falso si no lo es. == Advertencias == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> isAlphaNumeric('a'); //verdadero isAlphaNumeric('M'); //verdadero isAlphaNumeric('3'); //verdadero isAlphaNumeric(' '); //falso isAlphaNumeric('%'); //falso </syntaxhighlight> == Ejemplo 2 == Envía un carácter desde el monitor serie y veras si es de este tipo o no. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte caracter = Serial.Read(); if (isAlphaNumeric(caracter)){ Serial.print("SI"); }else{ Serial.print("NO"); } Serial.println(" es Alpha"); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] fefl8y8ou3nsqm9aiwrqv5fksnq1i0a 0 73 4686 4296 2019-07-07T01:17:19Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == Analiza si dato o variable es un carácter [[ASCII table]] (que sea un carácter entre 0-127 de la tabla). == Sintaxis == <pre> isAscii(dato); isAscii(variable); </pre> == Parámetros == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorna == Devuelve verdadero si es ASCII, falso si no lo es. == Advertencias == Nada. == Ejemplos == <pre> isAlpha('a'); //verdadero isAlpha('M'); //verdadero isAlpha('3'); //verdadero isAlpha(' '); //verdadero isAlpha('%'); //verdadero </pre> == Ejemplo 2 == Envía un carácter desde el monitor serie y veras si es de este tipo o no. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte caracter = Serial.Read(); if (isAscii(caracter)){ Serial.print("SI"); }else{ Serial.print("NO"); } Serial.println(" es ASCII"); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] fzfx2muqz6n4i1h1nhhpq8j54nvdlb9 0 74 4303 4214 2019-06-11T23:40:31Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si dato o variable es un carácter de control. == Sintaxis == <pre> isControl(dato); isControl(variable); </pre> == Parametro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si la dato o variable es un caracter de control o false si no lo es. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte c = Serial.read(); if (isControl(c)){ Serial.print("Es"); }else{ Serial.print("No es"); } Serial.println(" un caracter de control."); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] 709glfayxjxextj2br5fm90imhzqc5t 0 75 4302 4217 2019-06-11T23:40:05Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si parámetro es un dígito (0~9). == Sintaxis == <pre> isDigit(dato); isDigit(variable); </pre> == Parámetro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si parámetro es un dígito (0~9) o false si no lo es. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ char c = Serial.read(); if (isDigit(c)){ Serial.println("Es un carácter digito."); } } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] ibvl9peoq578hmavy9ep60j2rytx9sd 0 76 4304 4220 2019-06-11T23:40:53Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si dato o variable es un carácter gráfico imprimible (visible al imprimir; el espacio, tabulador y salto de línea no cuentan aquí). == Sintaxis == <pre> isGraph(dato); isGraph(variable); </pre> == Parámetro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si la dato o variable es un carácter gráfico imprimible o false si no lo es. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte c = Serial.read(); if (isGraph(c)){ Serial.print("Es"); }else{ Serial.print("No es"); } Serial.println(" un caracter grafico."); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] 62b7uxao77w6znnkhfy5f9b8r94w00c 0 77 4301 4222 2019-06-11T23:39:53Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si dato o variable es un dígito hexadecimal válido. Es decir 0~9 y A~F == Sintaxis == <pre> isHexadecimalDigit(dato); isHexadecimalDigit(variable); </pre> == Parámetro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si la dato o variable es un dígito hexadecimal o false si no lo es. == Advertencias == Nada. == Ejemplo == Envia un caracter desde el monitor serie y veras si es de este tipo o no. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte caracter = Serial.Read(); if (isHexadecimalDigit(caracter)){ Serial.print("SI"); }else{ Serial.print("NO"); } Serial.println(" es HexadecimalDigit"); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] m9wkl48xz59dx4mqfs2zvfo3sem4jmz 0 80 4305 4224 2019-06-11T23:42:00Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si el parámetro es un carácter en minúsculas. == Sintaxis == <pre> isLowerCase(dato); isLowerCase(variable); </pre> == Parámetro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si la dato o variable es un carácter minuscula o false si no lo es. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte c = Serial.read(); if (isLowerCase(c)){ Serial.print("Es"); }else{ Serial.print("No es"); } Serial.println(" un carácter minuscula."); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] jkn83ux5dthf6w110jwnd0zgo68u909 0 79 4300 4215 2019-06-11T23:39:39Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si dato o variable es un carácter imprimible. A diferencia de [[isGraph()]], caracteres como el espacio, tabulador y salto de línea sí cuentan. == Sintaxis == <pre> isPrintable(dato); isPrintable(variable); </pre> == Parámetro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si la dato o variable es un carácter imprimible o false si no lo es. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte c = Serial.read(); if (isPrintable(c)){ Serial.print("Es"); }else{ Serial.print("No es"); } Serial.println(" un carácter imprimible."); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] 7mozaiduv6ozlss9lgqmntqn7y9turr 0 78 4306 4216 2019-06-11T23:42:18Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si dato o variable es un carácter de puntuación. Es decir , . ; == Sintaxis == <pre> isPunct(dato); isPunct(variable); </pre> == Parámetro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si la dato o variable es un carácter de puntuación o false si no lo es. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ char c = Serial.read(); if (isPunct(c)){ Serial.print("Es"); }else{ Serial.print("No es"); } Serial.println(" un carácter de puntuacion."); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] 05r5gzn2mdnf550gftua67uj0ngfwyy 0 82 4299 4223 2019-06-11T23:39:26Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si parámetro es un carácter espaciador. Los demás caracteres mencionados en [[isWhiteSpace()]] no cuentan aquí. == Sintaxis == <pre> isSpace(dato); isSpace(variable); </pre> == Parametro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si la parámetro espaciador o false si no lo es. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte c = Serial.read(); if (isSpace(c)){ Serial.print("Es"); }else{ Serial.print("No es"); } Serial.println(" un espacio en blanco."); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] ekxmzhzvopx8mfg5xeplj80c5b9xk68 0 81 4298 4212 2019-06-11T23:39:12Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si parámetro es mayúscula. == Sintaxis == <pre> isUpperCase(dato); isUpperCase(variable); </pre> == Parametro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si la parámetro es mayúsculas o false si no lo es. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte c = Serial.read(); if (isUpperCosel(c)){ Serial.print("Es"); }else{ Serial.print("No es"); } Serial.println(" un carácter en mayuscula."); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] pf04hyqsj52sz9lwc2ez2w16s8zdhbz 0 83 4297 4225 2019-06-11T23:38:57Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Analiza si parámetro es un espacio en blanco (' '), salto de página ('\f'), salto de línea ('\n'), retorno del carro ('\r'), tabulador horizontal ('\t') o tabulador vertical ('\v'). == Sintaxis == <pre> isWhiteSpace(dato); isWhiteSpace(variable); </pre> == Parámetro == ;dato: dato a analizar. ;variable: nombre de variable a analizar. == Retorno == Devuelve true si parámetro es un espacio en blanco o false si no lo es. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()){ byte c = Serial.read(); if (isWhiteSpace(c)){ Serial.print("Es"); }else{ Serial.print("No es"); } Serial.println(" un carácter blanco."); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones caracteres</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones caracteres]] o1cf5dz9dfcazttxa03xx42vrqemlx8 0 409 5081 5080 2019-10-14T16:49:32Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Convierte un valor [[int]] en una cadena terminada en nulo usando la base especificada y almacena el resultado en la matriz dada por el parámetro str. == Sintaxis == <pre> itoa(valor, matriz, base); </pre> == Parámetros == ;valor:Valor [[int]] a convertir en una cadena caracteres (matriz). ;matriz:Nombre de la matriz en memoria donde almacenar la cadena resultante terminada en nulo. ;base:Base numérica usada para representar el valor como una cadena. Entre 2 y 36, donde 10 significa base decimal, 16 hexadecimal, 8 octal y 2 binarios. == Retorna == Un puntero a la cadena terminada en nulo resultante, igual que el parámetro '''matriz'''. == Comentario == * Si la base es 10 y el valor es negativo, la cadena resultante está precedida por un signo menos (-). Con cualquier otra base, el valor siempre se considera sin signo. == Advertencia == * Debe asignarse suficiente espacio a la matriz para contener la cadena devuelta. Puede devolver hasta 17 bytes. == Ejemplo 1 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); int n = 12345; char texto[5]; itoa(n, texto, 10); for (byte i=0; i<5; i++){ Serial.println(texto[i]); } } void loop(){ //Nada. } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); int n = 12345; char texto[16]; itoa(n, texto, 2); for (byte i=0; i<16; i++){ Serial.println(texto[i]); } } void loop(){ //Nada. } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> == Referencia == * [http://vitaly_filatov.tripod.com/ng/tc/tc_000.168.html itoa()] - Tripod [[Category:Funciones conversion]] f1u46mefks18smh1048n9hfgy6k9dbx 0 172 4288 4204 2019-06-11T23:34:05Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Logaritmo natural en base '''e'''. == Sintaxis == <pre> log(variable); </pre> == Parámetros == ;variable: Variable a evaluar. == Retorno == Logaritmo natural del numero. Es un numero tipo [[float]]. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> float a; void setup(){ Serial.begin(9600); for (byte i=1; i<10; i++) { a = log(i) ; Serial.print(i); Serial.print("\t"); Serial.println(a); } } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones matematicas</categorytree> == Referencias == * [https://www.prometec.net/funciones1/ Funciones] - Prometec * [https://www.prometec.net/funciones1/ Aprendiendo Arduino] - Enrique Crespo [[Category:Funciones matematicas]] o9yzx77s883ohieaj6ru86wct88p6ta 0 62 3676 3675 2019-05-06T18:39:32Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Es el formato numérico de 4 bytes (32 bits), son enteros comprendidos en el rango de -2147483648 a 2147483647 (2^31-1). {{Nota|Si se hace operaciones matemáticas con enteros, al menos uno de los números debe estar seguido de una '''L''', forzando a este número a ser un '''long'''.}} == Sintaxis == <pre> long variable [= valor]; variable = valorL; </pre> == Parámetros == ;variable: Una variable cualquiera ;valor: entre -2,147,483,648 y 2,147,483,647. Parámetro opcional. ;valorL: forzar tipo con subfijo '''L'''. Puedes omitir '''long''' antes del nombre de la variable. {| class="wikitable col2cen" |+Posibles formateadores !Base!!Subfijo!!Ejemplo |- |[[unsigned int]]||U||n = 123U |- |[[long]]||L||n = 123L |- |[[unsigned long]]||UL||n = 123UL |- |[[float]]||F||n =12.3F |} {| class="wikitable col2cen" |+Posibles formateadores !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1110011 |} == Advertencias == * Si sumas 1 al valor máximo que de 2,147,483,647 pasa a -2,147,483,648. * Si restas 1 al valor mínimo que de -2,147,483,648 pasa a 2,147,483,647. == Ejemplo == <syntaxhighlight lang="c++"> long n = 12345; x = 123U; //Con U forzamos unsigned int y = 123L; //Con L forzamos long z = 123UL; //Con UL forzamos unsigned long </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/long/ Guia de referencia de Arduino] * [https://www.arduino.cc/reference/es/language/variables/constants/integerconstants/ Guia de referencia de Arduino] [[Category:Tipo dato]] q990i8nm3zz7vym69nbnilpljqhwtbm 0 177 4312 4231 2019-06-11T23:47:22Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Convierte un valor en un dato tipo [[long]]. == Sintaxis == <pre> long(variable); </pre> == Parámetros == ;variable: variable de cualquier tipo a evaluar. == Retorna == Retorna un numero tipo [[long]]. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> char a = 'A'; byte b = 123; void setup(){ Serial.begin(9600); byte valor1 = byte(a); Serial.println(valor1); int valor2 = long(b); Serial.println(valor2); unsigned int valor3 = word(b); Serial.println(valor3); long valor4 = long(b); Serial.println(valor4); } void loop(){ //Nada. } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones conversion]] bl6u8rdvz22ys3px0rflgybzezvikgt 0 24 2164 2163 2018-07-24T22:39:22Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Después de la función [[setup()]], que inicializa y establece los valores iniciales, la funcion '''loop()''' hace exactamente lo que sugiere su nombre, ciclos consecutivos, permitiendo que su programa cambie y responda. Úselo para controlar activamente la placa Arduino. == Sintaxis == <pre> void loop(){ //Este código se repite una y otra vez. } </pre> == Advertencia == {{Nota|Es obligatorio que esta sentencia sea incluida en cada boceto, aunque puede estar vacía.}} == Ejemplo == <syntaxhighlight lang="c++"> const byte pulsador = 3; void setup(){ Serial.begin(115200); pinMode(pulsador, INPUT_PULLUP); } void loop(){ if (digitalRead(pulsador)){ Serial.println('H'); }else{ Serial.println('L'); } delay(1000); } </syntaxhighlight> == Vea tambien == * [[setup()]] * [[void]] [[Category:Estructura]] 73cxqj09kn0nbtks9j9b1b15qf66yt0 0 196 4700 4380 2019-07-14T17:41:38Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Extrae el byte de orden inferior (más a la derecha) de una variable (por ejemplo, una palabra). == Sintaxis == <pre> lowByte(variable); </pre> == Parámetros == ;variable: variable a evaluar que ser tipo [[int]], [[long]], [[float]], [[unsigned int]] o [[unsigned long]]. == Retornos == Retorna byte. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones bit y byte</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones bit y byte]] da2kqgogdo0u1t4bgsfy4mi6rskr68s 0 498 5078 5077 2019-10-13T14:35:26Z Kike GL 2 /* Advertencia */ wikitext text/x-wiki == Descripción == Convierte un valor [[long]] en una cadena terminada en nulo usando la base especificada y almacena el resultado en la variable de nombre dada por el parámetro matriz. == Sintaxis == <pre> ltoa(valor, matriz, base); </pre> == Parámetros == ;valor:Valor [[long]] a convertir en una cadena caracteres (matriz). ;matriz:Nombre de la matriz en memoria donde almacenar la cadena resultante terminada en nulo. ;base:Base numérica usada para representar el valor como una cadena. Entre 2 y 36, donde 10 significa base decimal, 16 hexadecimal, 8 octal y 2 binarios. == Retorna == Un puntero a la cadena terminada en nulo resultante, de nombre igual que el parámetro '''matriz'''. No hay retorno de error. == Comentario == * Si la '''base''' es 10 y el valor es negativo, la cadena resultante está precedida por un signo menos (-). Con cualquier otra base, el valor siempre se considera sin signo. == Advertencia == * Debe asignarse suficiente espacio a la matriz para contener la cadena devuelta. Puede devolver hasta 33 bytes. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); long n = 64000; char texto[33]; ltoa(n, texto, 10); for (byte i=0; i<33; i++){ Serial.println(texto[i]); } } void loop(){ //Nada. } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> == Referencia == * [http://vitaly_filatov.tripod.com/ng/tc/tc_000.181.html ltoa()] - Tripod [[Category:Funciones conversion]] 0nzkvm3qqw72qtsqkfy399dr8sm6psn 0 368 4844 4843 2019-07-25T00:52:27Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Asignar bloque de memoria. Asigna un bloque de bytes de tamaño de memoria y devuelve un puntero al principio del bloque. El contenido del bloque de memoria recién asignado no se inicializa, permaneciendo con valores indeterminados. Si el tamaño es cero, el valor de retorno depende de la implementación de la biblioteca en particular (puede o no ser un puntero nulo), pero el puntero devuelto no debe el[[iminarse. Este programa genera una cadena de la longitud especificada por el usuario y la rellena con caracteres alfabéticos. La longitud posible de esta cadena solo está limitada por la cantidad de memoria disponible paramalloc == Sintaxis == <pre> malloc(); </pre> == Parámetros == ;tamaño: Tamaño del bloque de memoria, en bytes. ;size_t: es un tipo entero sin signo. [[unsigned int]] == Retorno == * En caso de éxito, un puntero al bloque de memoria asignado por la función. El tipo de este puntero es siempre void*, que se puede convertir al tipo de puntero de datos deseado para que no se pueda distinguir. * Si la función no pudo asignar el bloque de memoria solicitado, se devuelve un puntero nulo. == Comentarios == * Solo se modifica el almacenamiento al que hace referencia el puntero devuelto. No se accede a ninguna otra ubicación de almacenamiento mediante la llamada. * Si la función reutiliza la misma unidad de almacenamiento liberada por una función de desasignación (comogratis o [[realloc()]]), las funciones se sincronizan de tal manera que la desasignación ocurre completamente antes de la siguiente asignación. == Advertencias == Nada. == Ejemplo == <pre> byte funcion(){ int i,n; char * buffer; printf ("How long do you want the string ?"); scanf ("%d", &i); buffer = (char*) malloc(i+1); if (buffer==NULL){ exit (1); } for (byte n=0; n<i; n++){ buffer[n]=rand()%26+'a'; } buffer[i]='\0'; printf ("Random string: %s\n", buffer); free (buffer); } </pre> == Vea también == * [[free()]] * [[calloc()]] * [[realloc()]] == Referencias == [[Category:Funciones]] lgi9cpj8j15miazqb4mq8abkgdjwlbl 0 166 4208 2320 2019-06-11T21:22:02Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Reasigna un número de un rango a otro. Es decir, un rango se correlacionaría con otro, pero no restringe dentro del rango. {{Nota|Esta función usa matemática entera, por lo que no produce fracciones.}} == Sintaxis == <pre> map(variable,min1,max1,min2,max2); </pre> == Parámetros == ;variable: variable a evaluar. ;min1: valor minimo de entrada. ;max1: valor maximo de entrada. ;min2: valor minimo de salida. ;max2: valor maximo de salida. == Retorna == Un valor en el rango de '''min2''' y '''max2'''. == Advertencias == Nada. == Ejemplo == <pre> int x; map(x, 0, 1023, 0, 255); //Muy usado para adaptar salida analogico a PWM. map(x, 1, 50, 50, 1); map(x, 1, 50, 50, -100); </pre> == Vea también == * [[abs()]] * [[constrain()]] * [[max()]] * [[min()]] * [[pow()]] * [[sq()]] * [[sqrt()]] * [[log()]] * [[ceil()]] * [[floor()]] == Referencias externas == * [https://www.arduino.cc/reference/en/language/functions/math/map/ Guia de referencia] [[Category:Funciones matematicas]] 73f65028u1k0g5cw4kw0x6z3p77xywx 0 485 5238 5237 2020-02-02T18:54:46Z Kike GL 2 /* Ejemplo 3 */ wikitext text/x-wiki == Descripcion == Una matriz (array en ingles) es una variable que puede contener multiples elementos del mismo tipo. == Sintaxis == <pre> tipo nombre[] = {elemento1, elemento2...}; tipo nombre[][n] = {{1,2,3},{4,5,6},{7,8,9}}; </pre> == Parámetros == ;tipo:puede ser [[char]], [[byte]], [[int]], [[unsigned int]], [[long]], [[unsigned long]] o [[float]]. ;nombre:es el nombre que se asignara a la matriz ;n:Es el numero de elementos == Comentarios == * En un matriz se puede obviar el numero de elementos (filas), pero en una matriz bidireccional es obligatorio indicar el numero de columnas. == Advertancia == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> char matriz1[] = "Arduino"; byte matriz2[] = {21,250,2,64}; int matriz3[] = {2019,7,14,8,0,0}; </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> const int matriz[][6] = { {2019,7,14,8,0,0}, {2019,7,19,8,0,0}, {2019,7,22,8,0,0} }; void setup(){ Serial.begin(9600); for (byte i=0; i<3; i++){ for (byte j=0; j<6; j++){ Serial.print(matriz[i][j]); } Serial.println(); } } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 3 == No se puede crear una '''matriz''' de matrices. Pero si se puede usar [[asterisco|punteros]] a matrices, asi: <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); byte cero[] = { 0xA6, 0xD4, 0xAC, 0xF8 }; byte uno[] = { 0xE9, 0x48, 0xCC, 0xE3 }; byte dos[] = { 0x46, 0x6F, 0xA5, 0xF8 }; byte tres[] = { 0xC2, 0x9D, 0xFC, 0x33 }; byte* matriz[4] = {cero, uno, dos, tres}; //Usando puntero for (byte i=0; i<4; i++){ for (byte j=0; j<4; j++){ Serial.print(matriz[i][j], HEX); Serial.print(", "); } Serial.println(); } } void loop() { //Nada } </syntaxhighlight> == Vea también == * [[variable publica]] * [[variable local]] * [[static]] * [[volatile]] * [[const]] * [[define|#define]] * [[Palabras reservadas]] * [[Comentarios]] - (//) * [[sizeof()]] == Referencias externas == * [https://aprendiendoarduino.wordpress.com/tag/arrays/ Arrays y String] - Aprendiendo Arduino * [https://www.luisllamas.es/arduino-array-dinamico/ Array dinamico] - Luis Llamas * [http://codigoelectronica.com/blog/arduino-array Array en Arduino] - Codigo electronica * [https://forum.arduino.cc/index.php?topic=208323.0 Matrices] - Foro Arduino [[Category:Variables]] 894qso6f0r9486wacz5jjz1hm13hr5k 0 167 5161 4293 2020-01-31T23:49:12Z Kike GL 2 /* Advertencias */ wikitext text/x-wiki == Descripción == Calcula el máximo de dos números para cualquier tipo de datos devolviendo el número mayor de los dos. == Sintaxis == <pre> max(num1,num); </pre> == Parámetros == ;num1: numero a comparar. Puede ser de cualquier tipo: [[char]], [[byte]], [[int]], [[float]]. ;num2: numero a comparar. == Retorno == Devuelve el numero mas grande. == Advertencias == * Debido a la forma en que se implementa la función '''max()''', evite usar otras funciones dentro de los corchetes, puede dar lugar a resultados incorrectos. <pre> max(n++, 100); //Evitalo, dara resultados incorrectos </pre> == Ejemplo 1 == <pre> max(3,6); //6 </pre> == Ejemplo 2 == Este codigo asegura que el valor de '''numero''' sera por lo menos 20. <pre> numero = max(numero, 20); </pre> == Vea también == <categorytree mode=all>Funciones matematicas</categorytree> == Referencias externas == [[Category:Funciones matematicas]] tf6et2ueid7uu8k84ghbjz650k2w9ay 0 101 4994 4712 2019-09-26T23:38:38Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == == Sintaxis == <pre> variable > valor; variable > expresion; variable1 > variable2; </pre> == Retorno == Verdadero si es mayor que y falso si no. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> if (x > 9){ //Es mayor }else{ //Es menor o igual } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador logico</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Operador comparador]] nejp5hkln38lszkc3qfyinfuzyref6u 0 102 5000 4999 2019-09-26T23:41:04Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Crea una condición comparando dos expresiones. Si la expresión a la izquierda en '''mayor o igual''' a la de la derecha se devuelve verdadero. == Sintaxis == <pre> variable >= valor; variable >= expresion; variable1 >= variable2; </pre> == Retorno == Verdadero si es mayor o igual y falso si no. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> if (x >= 9){ //Es mayo o igual }else{ //Es menor } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador comparador</categorytree> <categorytree mode=all>Operador logico</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Operador comparador]] rlj2cxdcoti07gmjaz0yf4dwckkqt4r 0 307 4545 4544 2019-06-27T00:14:49Z Kike GL 2 wikitext text/x-wiki Hay tres grupos de memoria en el uC usado en las placas Arduino basadas en AVR: * [[flash]] (espacio de programa), es donde se almacena el [[boceto]] Arduino. * [[SRAM]] (memoria de acceso aleatorio estática) es donde el boceto crea y manipula variables cuando se ejecuta. * [[EEPROM]] es un espacio de memoria que los programadores pueden usar para almacenar información a largo plazo. La memoria [[flash]] y la memoria [[EEPROM]] no son volátiles (la información persiste después de que se desconecta la alimentación). [[SRAM]] es volátil y se perderá cuando se apaga la corriente. {| class="wikitable col3cen col4cen col5cen" |+Memoria disponible !Placa!!uC!![[flash]]!![[SRAM]]!![[EEPROM]] |- |[[UNO]]||ATmega328||32KB||2KB||1KB |- |[[NANO]]||ATmega328P||32KB||2KB||1KB |- |[[MEGA]]||ATmega2560||256KB||8KB||4KB |} == Comentarios == Si se queda sin [[SRAM]], su programa puede fallar de maneras inesperadas; parecerá que se carga con éxito, pero no se ejecuta o se ejecuta de forma extraña. Para comprobar si esto está sucediendo, puede intentar comentar o acortar cadenas u otras estructuras de datos en su [[boceto]] (sin cambiar el código). Si luego se ejecuta con éxito, probablemente se está quedando sin [[SRAM]]. Hay algunas cosas que puede hacer para resolver este problema: * Si su [[boceto]] habla con un programa que se ejecuta en una computadora, puede intentar transferir datos o cálculos a la computadora, reduciendo la carga en el Arduino. * Si tiene tablas de búsqueda u otras matrices grandes, use el tipo de datos más pequeño necesario para almacenar los valores que necesita; por ejemplo, un [[int]] ocupa 2 bytes (16 bits), mientras que un [[char]] o [[byte]] usa solo un byte (8 bits), pero almacenar un rango más pequeño de valores. * Si no necesita modificar las cadenas o datos mientras se ejecuta su boceto, puede almacenarlos en memoria [[flash]] (programa) en lugar de [[SRAM]]; para hacer esto, use la palabra clave [[PROGMEM]]. == Advertencias == * Las notas en esta página son para todas las tablas excepto [[DUE]], que tiene una arquitectura diferente. == Ejemplo == <syntaxhighlight lang="c++"> for (byte i=0; i<10; i++){ free(matriz[i]); } free(matriz); </syntaxhighlight> == Vea también == * [[flash]] * [[SRAM]] * [[EEPROM]] * [[IDE]] * [[boceto]] * [[Estructura]] * [[Variables]] * [[Funciones]] == Referencias == * [https://www.arduino.cc/en/Tutorial/Memory Guia de referencia Arduino] [[Category:memoria]] ff0jbs73ong0h0cft96oys5oqevbhez 0 103 4996 4711 2019-09-26T23:39:18Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == == Sintaxis == <pre> variable < valor; variable < expresion; variable1 < variable2; </pre> == Retorna == * Verdadero so es menos y falso si no. == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> if (x < 9){ //Es menor }else{ //Es mayor o igual } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador logico</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Operador comparador]] g1ap6arnur6rh30nykvwg3rqp16lhn5 0 104 4995 4710 2019-09-26T23:39:03Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == == Sintaxis == <pre> variable <= valor; variable <= expresion; variable1 <= variable2; </pre> == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> if (x <= 9){ //Es menor o igual }else{ //Es mayor } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador logico</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Operador comparador]] qwsa1lhe3jq4c0ot396b9g2e123yfbo 0 32 4922 4279 2019-09-21T14:03:29Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == Devuelve el número de microsegundos desde la que placa Arduino empezó a ejecutar el [[boceto]] actual. Este número se desbordará (volverá a cero), después de aproximadamente 70 minutos. 1 segundo = 1000 000 microsegundos. == Sintaxis == <pre> micros(); </pre> == Parámetros == Ninguno. == Retornos == Número de microsegundos desde que se inició el boceto. Tipo de dato [[unsigned long]]. == Comentarios == {{Tip|Este comando tarda 47 ciclos de CPU.}} == Advertencias == * En placas Arduino de 16 MHz (UNO, Duemilanove y NANO), esta función tiene una resolución de '''cuatro microsegundos''', es decir el valor devuelto es siempre un múltiplo de cuatro. * En las placas Arduino 8 MHz (LilyPad), esta función tiene una resolución de '''ocho microsegundos''', es decir el valor devuelto es siempre un múltiplo de ocho. * '''micros()''' funciona mediante una interrupción (la misma de [[millis()]]); por lo tanto, su valor dejará de incrementar (pero puede variar sólo un poco) durante una rutina de servicio de interrupción (ej.: posterior a [[attachInterrupt()]]), o mientras no se llame a [[interrupts()]] después de llamar a [[noInterrupts()]]. == Ejemplo == <pre> unsigned long tiempo; void setup(){ Serial.begin(9600); } void loop(){ Serial.print("Tiempo: "); tiempo = micros(); // Imprime los microsegundos transcurridos desde que se inició el programa Serial.println(tiempo); // Esperar un segundo para así no inundar el puerto con muchos datos delay(1000); } </pre> == Vea también == <categorytree mode=all>Funciones tiempo</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/micros/ Guia de referencia de Arduino] [[Category:Funciones tiempo]] b59obbfqkddvfp96utfai5d9p0nemsp 0 30 4836 4835 2019-07-25T00:38:13Z Kike GL 2 /* Ejemplo 2 */ wikitext text/x-wiki == Descripción == Devuelve el número de milisegundos desde que la placa Arduino empezó a ejecutar el programa actual. Este número se desbordará (volverá a cero), después de aproximadamente 50 días. == Sintaxis == <pre> millis(); </pre> == Parámetros == Nada. == Retornos == Número de milisegundos desde que el programa se inició. Numero tipo [[unsigned long]]. == Comentario 1 == Ya que una variable [[unsigned long]] almacena numero entre 0 y 4,294,967,295 (2^32-1), esta función se vuelve a 0 a los 49.71 días pero eso no representa ningún problema para los cálculos porque al no aceptar numero negativos la variable se da la vuelta por decirlo de alguna manera. Para que te quede claro simplificaremos con un ejemplo: supongamos que nuestra variable solo soporte 0 a 99 osea 100 '''números'''. Ahora te pregunto cuanto es 0 - 1 ? en nuestro ejemplo la respuesta correcta es 99 porque es el numero que esta antes de 0. Exactamente por el otro extremo el numero que sigue de 99 es 0. A esto se le llama lógica boleana. Ahora supongamos que quieres prende un foco por 10 '''números''' e inicias el proceso en 22, por lo que preguntas if ('''números''' - tiempo = 10), se apagaría cuando '''números''' llegue a 32 (32 - 22 = 10). Ahora supón que se prende en 95, cuando apagara ? la respuesta es cuando '''números''' llegue a 5 (5 - 95 = 10). {{Tip|Este comando tarda 21 ciclos de CPU.}} == Comentario 2 == Se puede resetear el temporisador de millis() ? <syntaxhighlight lang="c++"> extern volatile unsigned long timer0_millis; unsigned long nuevo_valor = 0; void setup(){ //Algo } void loop(){ //Algo //-------- //Change Millis setMillis(nuevo_valor); } void setMillis(unsigned long nuevo_valor){ uint8_t oldSREG = SREG; cli(); timer0_millis = nuevo_valor; SREG = oldSREG; } </syntaxhighlight> == Advertencias == * Tenga en cuenta el tipo de valor que retorno '''millis()''' es [[unsigned long]] y pueden producirse errores lógicos si hacer operaciones aritméticas con otros tipos de datos más pequeños como: [[byte]] o [[int]], incluso los [[long]] con signo pueden producir errores de calculo. * '''millis()''' funciona mediante una interrupción (la misma de [[micros()]]); por lo tanto, su valor dejará de incrementar durante una rutina de servicio de interrupción (ej.: posterior a [[attachInterrupt()]]), o mientras no se llame a [[interrupts()]] después de llamar a [[noInterrupts()]]. == Ejemplo 1 == Parpadeo del LED incorporado sin usar [[delay()]] <syntaxhighlight lang="c++"> unsigned long t; //Es muy importante respetar el tipo de dato void setup() { pinMode(LED_BUILTIN, OUTPUT); } void loop() { if (milis() - t >= 500){ t = millis(); //Guarda la hora de cada cambio. digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); //Invierte valor del pin. } } </syntaxhighlight> == Ejemplo 2 == Parpadeo cada segundo sin usar [[delay()]]. <syntaxhighlight lang="c++"> unsigned long t; //Es muy importante respetar el tipo de dato const int d = 2000; //Duración en milisegundos del ciclo completo void setup() { pinMode(13, OUTPUT); } void loop() { t = millis(); if (t%d > d/2){ digitalWrite(13, HIGH); //Prende LED }else{ digitalWrite(13, LOW); //Apaga LED } } </syntaxhighlight> == Ejemplo 3 == En este ejemplo simularemos las direcionales de un auto, para lo que tenemos 2 pulsadores y 2 LED. Cada vez que pulso un botón el LED correspondiente parpadea cada 250 ms durante 3 segundos. <syntaxhighlight lang="c++"> unsigned long izq,der,ti,td; bool LEDi,LEDd,actual_i,actual_d,anterior_i,anterior_d; void setup(){ pinMode(2, INPUT); //Pulsador derecho pinMode(3, INPUT); //Pulsador izquierdo pinMode(8, OUTPUT); //LED izquierdo pinMode(9, OUTPUT); //LED derecho } void loop(){ //Prende actual_i = digitalRead(3); if (actual_i && !anterior_i){ LEDi = true; izq = millis(); } anterior_i = actual_i; actual_d = digitalRead(2); if (actual_d && !anterior_d){ LEDd = true; der = millis(); } anterior_d = actual_d; //Parpadea if (LEDi && (millis()-ti > 250)){ digitalWrite(8, !digitalRead(8)); ti = millis(); } if (LEDd && (millis()-td > 250)){ digitalWrite(9, !digitalRead(9)); td = millis(); } //Apaga if (millis() - izq > 3000){ LEDi = false; digitalWrite(8, LOW); } if (millis() - der > 3000){ LEDd = false; digitalWrite(9, LOW); } } </syntaxhighlight> {{Nota|Hay 3 zonas en el código la primera llamada prende, aunque en realidad solo cambia el estado de una variable de tipo flag (LEDi o LEDd) e inicia el tiempo total de 3 seg (ti o td). Una 2da zona donde se hace parpadear los LED mientras la variable flag este en verdadero (LEDi o LEDd). Por ultimo esta la zona de apagado que es cuando se cumplan los 3 segundos.}} == Vea también == <categorytree mode=all>Funciones tiempo</categorytree> == Referencias externa == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [https://tomblanch.wordpress.com/2013/07/27/resetting_millis/ Resetting the Arduino millis() count] - Tom Blanchard * [https://www.gammon.com.au/millis millis() desbordamiento, es malo ?] - Nick Gammon * [https://www.gammon.com.au/blink Como hacer varias cosas a la vez] - Nick Gammon * [http://www.gammon.com.au/statemachine Maquina de estados] - Nick Gammon [[Category:Funciones tiempo]] meeovfx0rxwwrxehey22olob4uux70a 0 168 5162 5160 2020-01-31T23:49:41Z Kike GL 2 /* Advertencias */ wikitext text/x-wiki == Descripción == Calcula el mínimo de dos números para cualquier tipo de datos devolviendo el número más pequeño. == Sintaxis == <pre> min(num1,num2); </pre> == Parámetros == ;num1: numero a comparar. ;num2: numero a comparar. == Retorna == Retrna el numero mas pequeños. == Advertencias == Debido a la forma en que se implementa la función '''min()''', evite usar otras funciones dentro de los corchetes, puede dar lugar a resultados incorrectos. <pre> min(n++, 100); //Evitalo, dara resultados incorrectos </pre> == Ejemplo == <pre> min(3,6); //3 </pre> == Vea también == <categorytree mode=all>Funciones matematicas</categorytree> == Referencias externas == [[Category:Funciones matematicas]] 75rt6k51kk3jrdtmasr8ex7lzw6mfhz 0 95 5037 4723 2019-09-27T00:22:06Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == La operación '''modulo''' calcula el resto cuando un entero se divide por otro. Es útil para mantener una variable dentro de un rango particular (por ejemplo, el tamaño de una matriz). El símbolo % (por ciento) se usa para llevar a cabo la operación de módulo. {{Nota|si el segundo operando o divisor es cero, el resultado será igual al valor del primer operando o dividendo.}} {{Nota|si el segundo operando o divisor es uno, el resultado siempre será cero.}}{{Nota|el signo del resultado dependerá solamente de el del primer operando o dividendo.}} == Sintaxis == <pre> op1 % op2 </pre> == Parametros == ;op1: primer operando, es el dividendo. ;op2: segundo operando, es el divisor. == Retorna == Retorna el resto. == Comentarios == == Advertencias == * Esta operación es válida únicamente entre valores enteros; con que al menos uno de los dos operandos sea punto flotante, habrá un error de compilación. == Ejemplo 1 == <syntaxhighlight lang="c++"> x = 5 % 5; //0 x = 8 % 2; //0 x = 7 % 5; //2 x = 9 % 5; //4 x = 4 % 5; //4 </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); for (byte n=1; n<100; n++){ Serial.print(n); if (n%2 == 0){ Serial.println(" es par"); }else{ Serial.println(" es impar"); } } } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/structure/arithmetic-operators/remainder/ Guia de referencia de Arduino] * [https://aprendiendoarduino.wordpress.com/2018/04/08/operadores-5/ Aprendiendo Arduino] [[Category:Operador aritmetico]] jzvxip4azsklp02omtz8s8cfijahh4y 0 217 5012 5008 2019-09-26T23:58:13Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Divide la variable entre un valor y guarda el resto en la misma variable. {{Tip|Es lo mismo que variable <nowiki>=</nowiki> variable % valor}} == Sintaxis == <pre> variable %= valor; variable = variable % valor; </pre> == Parámetros == ;variable: Nombre de la variable a operar. Puede ser de cualquier tipo: [[byte]], [[int]], [[long]], [[float]]. ;valor: Valor del mismo tipo que variable. == Retorno == Nada. == Comentarios == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> byte n = 24; n %= 5; //4 n %= 3; //1 </syntaxhighlight> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias == [[Category:Operador aritmetico compuesto]] 80dr57t7sketyf6pqho8i0g0nd37i0x 0 215 5009 4730 2019-09-26T23:56:29Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Multiplica la variable entre un valor y guarda el resultado en la misma variable {{Nota|Es lo mismo que variable <nowiki>=</nowiki> variable * valor}} == Sintaxis == <pre> variable *= valor; variable = variable * valor; </pre> == Parametros == ;variable: Nombre de la variable a operar. ;valor: valor a incluir. == Retorno == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> byte n = 2; n *= 2; //4 n *= 2; //8 </syntaxhighlight> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador logico</categorytree> == Referencias == [[Category:Operador aritmetico compuesto]] rjf5tfcrhe2o7km8pqqdvrmdou59fz2 0 93 5036 5035 2019-09-27T00:21:41Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == La multiplicación es una de las cuatro operaciones aritméticas primarias. El operador *(asterisco) opera en dos operandos para producir el producto. == Sintaxis == <pre> variable = valor * variable * expresion; </pre> == Parámetros == ;variable:Nombre de la variable ;valor:Valor a asignar a la variable ;expresion: == Advertencias == * Al hacer operaciones aritméticas preste atención a los tipo de dato involucrados. * Debido a que toda variable tiene un límite, una multiplicación que resulte en un valor extremedamente alto puede tener un resultado sin sentido (por desbordamiento). Por ejemplo: que una multiplicación de dos enteros positivos resulte en un valor negativo (si la variable es con signo), o que sea menor que el primer operando (si la variable es sin signo). * Por lógica, si la variable donde se almacenará el resultado no tiene signo, este jamás será negativo aunque uno de los operandos sea negativo. == Ejemplo == <pre> int x = 10; int y = 5; x = 2*x; /20 x *= y //100 (Multiplica x por y) </pre> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/structure/arithmetic-operators/multiplication/ Guia de referencia de Arduino] * [https://aprendiendoarduino.wordpress.com/2018/04/08/operadores-5/ Aprendiendo Arduino] [[Category:Operador aritmetico]] 9u6j84c8p2jhnky1bxm6ih6fw7jw64l 0 401 2905 2019-04-03T22:08:49Z Kike GL 2 Página creada con «== Descripción == == Sintaxis == == Parámetros == == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == * [[string]] *...» wikitext text/x-wiki == Descripción == == Sintaxis == == Parámetros == == Advertencias == == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == * [[string]] * [[strlen()]] == Referencias == * [https://www.luisllamas.es/convertir-texto-a-numero-arduino/ Convertir texto a numero] - Luis Llamas * [http://panamahitek.com/tipos-de-datos-arrays-en-arduino/ Tipos de datos: Arrays] - José Villalaz [[Category:Variables]] i8w2na0kxoaur0t6ze467m12tzvd3gh 0 43 4263 2041 2019-06-11T23:11:11Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Deshabilita las interrupciones (que después se pueden rehabilitar con [[interrupts()]]. Las interrupciones permiten que ciertas tareas importantes que suceden en segundo plano sean activadas por defecto. Algunas funciones no trabajarán mientras las interrupciones están deshabilitadas, y las comunicaciones entrantes pueden ser ignoradas. Las interrupciones pueden alterar ligeramente la sincronización de código, sin embargo, y pueden ser desactivadas de los sectores especialmente críticos del código. == Sintaxis == <pre> noInterrupts(); </pre> == Parámetros == Nada. == Retornos == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup() { //Nada } void loop(){ noInterrupts(); //Aquí el código sensible al tiempo interrupts(); //Aquí el resto de código } </syntaxhighlight> == Vea también == * [[interrupts()]] * [[attachInterrupt()]] * [[detachInterrupt()]] == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [http://www.gammon.com.au/interrupts Nick Gammon] [[Category:Funciones interrupciones]] 0a4vj9qoor79wghcm6soe0f0k08drlq 0 56 4283 4239 2019-06-11T23:30:00Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Detiene la generación de una onda cuadrada disparada por [[tone()]]. No tiene efecto si no se está generando un tono. {{Nota|Si desea reproducir tonos diferentes en varios pines, es necesario llamar noTone() en un pin antes de llamar a [[tone()]] en el siguiente pin.}} == Sintaxis == <pre> noTone(pin); </pre> == Parámetros == ;pin: el pin en el que se está generando el tono. == Retornos == Nada. == Advertencias == Nada. == Ejemplo == <pre> </pre> == Vea también == <categorytree mode=all>Funciones tiempo</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/noTone/ Guia de referencia de Arduino] [[Category:Funciones tiempo]] 61t7uynodketv8zk52aurpdhd2sa7ag 0 96 5297 5291 2020-06-06T21:40:29Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Niega una expresión (invierte su valor de verdad) se representa con carácter de admiración (!). {| class="wikitable col2cen" !a!!<nowiki>!</nowiki>a |- |0||1 |- |1||0 |} {{Nota| Recuerde que [[true / false|false]], 0 y [[HIGH / LOW|LOW]] son sinonimos, si como [[true / false|true]], cualquier numero distinto a o y [[HIGH / LOW|HIGH]] también lo son.}} == Sintaxis == <pre> !variable; not variable; !expresion; </pre> == Parámetros == ;variable: variable del tipo boleana. Ejemplo q=false; ;expresion: expresion cuya evaluacion debe ser verdero o falso. Ejemplo x>5; == Retorno == Retorna la variable negada. == Advertencias == * No confundir el operador boleano not ('''<nowiki>!</nowiki>'''), con el operador [[not bit a bit]] ('''~'''). == Ejemplo 1 == <syntaxhighlight lang="c++"> bool a = false; bool a = 0; bool a = LOW; !a //verdadedo en todos los casos </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> byte a=5; a>2; //Verdadero !a>2; //Falso </syntaxhighlight> == Ejemplo 3 == Un parpadeo simple del LED a bordo. <syntaxhighlight lang="c++"> void setup(){ pinMode(LED_BUILTIN, OUTPUT); } void loop(){ digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); delay(500); } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador logico</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [https://programarfacil.com/blog/programacion/la-logica-en-la-programacion/ La lógica en la programacion] - Luis Del Valle * [http://manueldelgadocrespo.blogspot.com/p/blog-page_8.htm Documentacion en español] - Manuel Delgado * [https://aprendiendoarduino.wordpress.com/category/operadores/ Operadores] - Aprendiendo Arduino [[Category:Operador logico]] dmv2i7sq7gtjuj2e7v52jfc8u5vne7l 0 206 4993 4992 2019-09-26T23:36:18Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == El operador '''not bit a bit''' es representado por el caracter tilde '''~'''. Opera sobre el numero a su derecha cambiando cada bit a su valor opuesto, es decir: cada 0 se convierte en 1 y 1 se convierte en 0. {| class="wikitable col2cen" !a!!~a |- |0||1 |- |1||0 |} == Sintaxis == <pre> ~variable; </pre> == Parametros == ;variable: una variable tipo numerica. == Retorno == El valor de dicha variable, pero con todos sus bits invertidos. == Advertencias == * No confundir el operador bit a bit not con el boleano [[not]] <nowiki>!</nowiki> == Ejemplo == <pre> byte a = B11110000; byte b = ~a; //B00001111 int a = 103; //B0000000001100111 = 103 int b = ~ a; //B1111111110011000 = -104 x = ~ x; // alternar todos los bits en x y almacenar de nuevo en x </pre> == Vea también == Operatores logicos * [[not]] <nowiki>(!)</nowiki> * [[and]] <nowiki>(&&)</nowiki> * [[or]] <nowiki>(||)</nowiki> * [[xor]] <nowiki>(^)</nowiki> Operadores bit a bit * [[and bit a bit]] <nowiki>(&)</nowiki> * [[or bit a bit]] <nowiki>(|)</nowiki> * [[xor bit a bit]] <nowiki>(^)</nowiki> <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [https://playground.arduino.cc/Code/BitMath/#bitwise_not Bitwise NOT] - Playgorund [[Category:Operador bit a bit]] pjjwdo5vwt4my1wlpvp75pv1k8v22on 0 398 5149 5148 2020-01-23T17:00:35Z Kike GL 2 /* Parámetros */ wikitext text/x-wiki == Descripción == Lee la fecha y hora actual desde le reloj. == Sintaxis == <pre> //#include <Wire.h> //Solo si usas reloj físico #include <RTClib.h> RTC_Millis rtc; //Reloj por software //RTC_DS1307 rtc; //Reloj con DS1307 //RTC_DS3231 rtc; //Reloj con DS3231 //RTC_PCF8523 rtc; //Reloj con PCF8523 DateTime hoy = rtc.now(); </pre> == Parámetros == ;hoy:Nombre de la variable de tipo [[DateTime]] == Retorno == Fecha y hora actual en formato UnixTimeStamp del tipo [[DateTime]] == Comentarios == Nada == Advertencia == Cuidado porque existe la función '''now()''' en ambas librerias [[Time|TimeLib.h]] y [[RTC|RTClib.h]]. == Ejemplo 1 == <syntaxhighlight lang="c++"> //#include <Wire.h> #include <RTClib.h> RTC_Millis rtc; //Reloj por software //RTC_DS1307 rtc; //Reloj con DS1307 //RTC_DS3231 rtc; //Reloj con DS3231 DateTime hoy,anterior = 0; void setup () { Serial.begin(57600); //Para setear RTC con fecha y hora cuando se compila //rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); //Para setear RTC a 21-MAR-2019 8:00:00 rtc.adjust(DateTime(2019, 3, 21, 8, 0, 0)); } void loop(){ hoy = rtc.now(); if (hoy.second() != anterior.second()){ anterior = hoy; Serial.print(hoy.year()); Serial.print('-'); Serial.print(hoy.month()); Serial.print('-'); Serial.print(hoy.day()); Serial.print(' '); Serial.print(hoy.hour()); Serial.print(':'); Serial.print(hoy.minute()); Serial.print(':'); Serial.println(hoy.second()); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria RTC</categorytree> == Referencias == * [https://github.com/adafruit/RTClib RTClib] - Adafruit [[Category:Libreria RTC]] 8gh8bb3pz7680dp4a7bn6hvne79uiax 0 342 3630 3629 2019-05-06T18:19:47Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Convierte el contenido de una cadena como una cadena terminada en nulo al estilo C ([[string]]). Tenga en cuenta que esto le da acceso directo a la memoria intermedia interna [[String]] y se debe usar con cuidado. == Sintaxis == <pre> objeto.c_str() </pre> == Parámetros == ;objeto: nombre de la instanciado de clase [[String]]. == Retorna == Un puntero al estilo C de la cadena invocadora ([[const]] [[char]]*). == Advertencias == * Cuando modifica el objeto [[String]], o cuando se destruye, cualquier puntero devuelto previamente por '''c_str()''' deja de ser válido y no debe seguir usandose. * En particular, nunca debe modificar la cadena a través del puntero devuelto; de lo contrario, podrían ocurrir discrepancias con los contadores internos, y por ende, comportamiento indefinido al operar con el objeto. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/c_str/ Guia de referencia de Arduino] [[Category:String]] 3ma8md8cwyqgh8sdylsri6t1k0ew5gq 0 340 3636 3635 2019-05-06T18:21:45Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Accede a un caracter particular de la cadena. == Sintaxis == <pre> variable.charAt(n); </pre> == Parámetros == ;variable: objeto instanciado de la clase [[String]] ;n: índice del caracter ([[unsigned int]]); el primer caracter está en la posición 0 (relativo al cero). == Retorna == El n-ésimo caracter de la cadena ([[char]]). == Advertencias == Nada. == Ejemplos == <syntaxhighlight lang="c++"> String cadena = "Apuntes de Arduino"; cadena.chatAt(0); //A cadena.chatAt(6); //s cadena.chatAt(11); //A </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:String]] s07cqrn7i136frmqqbq7iq9cz5b5h8r 0 348 3612 3611 2019-05-06T18:11:39Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Compara dos cadenas, probando si una viene antes o después de la otra en orden de la tabla ASCII o si son iguales. Las cadenas se comparan carácter por carácter, usando los valores ASCII de los caracteres. {{Nota|esta es la función que se ejecuta implícitamente cuando se utiliza el operador [[menor]], [[mayor]], [[menor igual]] o [[mayor igual]] en este tipo de dato.}} == Sintaxis == <pre> objeto.compareTo(cadena); </pre> == Parámetros == ;objeto: nombre del objeto instancia de clase [[String]]. ;cadena: variable tipo [[String]] == Retorna == ;cero: Si las cadenas son iguales. ;positivo: Si el objeto viene antes de la cadena. ;negativo: Si el objeto viene despues de la cadena. == Comentarios == Por ejemplo: 'a' (97) viene antes de 'b' (98) pero después de 'A' (65). Los números vienen antes de las letras. El 0 esta en posicion 48. == Advertencias == La comparación es sensible a las mayúsculas; para sobrellevar este problema, ambas cadenas tendrían que pasar por [[objeto.toLowerCase()]] o [[objeto.toUpperCase()]] de antemano. == Ejemplo == Tenemos que la primera letra de ambas cadenas coinciden y las segundas letras son p (70) y r (72), asi que la respuesta es la diferencia. <syntaxhighlight lang="c++"> String frase1 = "Apuntes"; String frase2 = "Arduino"; frase1.compareTo(frase2); //-2 (70-72) frase2.compareTo(frase1); //2 (72-70) </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/compareto/ Guia de referencia de Arduino] [[Category:String]] 5jgl6h06oi273hw7ixb3p2t4yrxslor 0 338 3620 3619 2019-05-06T18:16:18Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Contatena (adjunta) el parametro dado. {{Nota|esta es la función que se ejecuta implícitamente cuando se utiliza el operador '''+''' en este tipo de dato.}} == Sintaxis == <pre> objeto.concat(param); </pre> == Parámetros == ;objeto: instancia de la clase [[String]]. ;param: parametro a concatenar al final de la cadena ([[String]], [[string]], [[char]], [[byte]], [[int]], [[unsigned int]], [[long]], [[unsigned long]], [[float]], [[double]], [[F()|__FlashStringHelper]]). == Retorna == [[bool]]: '''verdadero''' si se pudo concatenar; '''falso''' en caso contrario (usualmente es seña de que la memoria [[SRAM]] está por llenarse o la cadena actual es demasiado grande). == Advertencias == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> String frase = "Apuntes"; frase.concat(" de "); //Apuntes de frase.concat("Arduino."); //Apuntes de Arduino. </syntaxhighlight> == Ejemplo 2 == Mira como podemos concatenar un valor numerico a una variable [[String]] <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); String sensor = "Sensor: "; sensor.concat(analogRead(A0)); Serial.println(sensor); } void loop(){ } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:String]] h5ha4c4l37d2w7tq6aewfdixgl9kqgg 0 356 3608 3607 2019-05-06T18:10:17Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Comprueba si un objeto termina con los caracteres de otra cadena. == Sintaxis == <pre> objeto.endsWith(cadena); </pre> == Parámetros == ;objeto: nombre de la instancia de la clase [[String]] ;cadena: cadena tipo [[String]] == Retorna == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); Serial.println("Ejemplos con: startsWith() y endsWith():"); } void loop ( ) { String cadena = "HTTP / 1.1 200 OK"; Serial.println(cadena); //Comprueba si comienza con una cadena particular if (cadena.startsWith("HTTP / 1.1")) { Serial.println("El servidor usa http versión 1.1"); } //Buscar en una posición de desplazamiento en la cadena if (cadena.startsWith("200 OK",9)){ Serie.println("Obtuve un OK del servidor"); } //Comprueba si un objeto termina con un caracter en particular String sensor = "sensor = "; sensor += analogRead(A0); Serial.print(sensor); if (sensor.endsWith("0")) { Serial.println(". Esta lectura es divisible por diez."); }else{ Serial.println(". Esta lectura no es divisible por diez."); } //No hacer nada mientras sea verdadero: while (true) ; } </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/endswith/ Guia de referencia de Arduino] [[Category:String]] q8yw98lnbg970s7rc5bxdv1fre3lgvx 0 354 3610 3609 2019-05-06T18:11:05Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Compara dos cadenas para la igualdad. La comparación distingue entre mayúsculas y minúsculas, lo que significa que la cadena "hola" no es igual a la cadena "Hola". {{Nota|esta es la función que se ejecuta implícitamente cuando se utiliza el operador [[igualdad]] o [[diferente]] en este tipo de dato.}} == Sintaxis == <pre> objeto.equals(cadena); </pre> == Parámetros == ;objeto: nombre del objeto instanciado de la clase [[String]]. ;cadena: cadena a comparar ([[String]]). == Retorna == [[bool]]: '''true''' si cadena es igual a cadena, '''false''' de lo contrario. == Advertencias == Para una verificación que no distinga mayúsculas, utiliza [[objeto.equalsIgnoreCase()]] en su lugar. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/equals/ Guia de referencia de Arduino] [[Category:String]] k2km1k5wvz5uk2zeheu3h1f9qqvqq9q 0 355 3628 3627 2019-05-06T18:19:09Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Compara dos cadenas para la igualdad. La comparación '''no''' distingue entre mayúsculas y minúsculas, lo que significa que la cadena "hola" es igual a la cadena "Hola". == Sintaxis == <pre> objeto.equalsIgnoreCase() </pre> == Parámetros == ;objeto: nombre del objeto instanciado de la clase [[String]]. ;cadena: cadena a comparar ([[String]]). == Retorna == [[bool]]: '''true''' si cadena es igual a cadena, '''false''' de lo contrario. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:String]] 9mx9f2aftdec4d3hsmmv7i34mm4i1to 0 180 3588 3579 2019-05-06T18:02:17Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Copia los caracteres de la cadena al bufer provisto. == Sintaxis == <pre> objeto.getBytes(bufer, largo); </pre> == Parámetros == ;objeto: nombre del objeto instanciado de la clase [[String]]. ;bufer: el búfer para copiar los caracteres en tipo [[byte]]. ;largo: el tamaño del búfer, tipo [[unsigned int]] == Retorna == El [[byte]] elegido. == Comentarios == Nada. == Advertencias == * Recuerde que "0" corresponde al codigo ASCII 48 y "9" al codigo 57. Ver [[tabla ASCII]]. * La longitud del buffer debe respetarse, de lo contrario se corre el riesgo de un "desbordamiento de buffer" que puede corromper el contenido la memoria de ejecución ([[SRAM]]). == Ejemplo == Este ejemplo se ejecuta una sola vez. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); String cadena = "0123456789"; byte matriz[cadena.length()]; cadena.getBytes(matriz, cadena.length()); //Convierte a byte for (byte i=0; i<cadena.length(); i++){ Serial.println(matriz[i]); delay(100); } } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/getbytes/ Guia de referencia de Arduino] [[Category:String]] jsdbpscd2nuh9ed909lfqlh241ntl0u 0 341 3591 3590 2019-05-06T18:03:12Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Retorna la primera posición del caracter o cadena dados. == Sintaxis == <pre> objeto.indexOf(c[, desde]); </pre> == Parámetros == ;objeto: Instancia de la clase [[String]]. ;c: Carácter o cadena a buscar dentro del objeto ([[char]], [[string]] o [[String]]). ;desde: Permite buscar una coincidencia desde cierta posición. == Retorna == La posicion hallada, o -1 si no lo encuentra ([[int]]). == Advertencias == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> String frase = "Apuntes de Arduino"; frase.indexOf('A'); //0 frase.indexOf('A',2); //11 frase.indexOf('m'); //-1 </syntaxhighlight> == Ejemplo 2 == En este ejemplo ponemos en el monitor serie algo como 123,456,789 y obtendremos 456.00 el numero entre las , en [[float]] <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); } void loop() { String num = ""; while (Serial.available()){ char c = Serial.read(); num = num + c; delay(10); } if (num != ""){ byte pos1 = num.indexOf(",") +1; byte pos2 = num.indexOf(",",pos1); float n = num.substring(pos1,pos2).toFloat(); Serial.println(n); } } </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:String]] 7n71dr7rkov26t8t52pxj0bqatuzjqc 0 357 3624 3623 2019-05-06T18:17:43Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Retorna la última posición del caracter o cadena dados. == Sintaxis == <pre> variable.lastIndexOf(valor); variable.lastIndexOf(valor, desde); </pre> == Parámetros == ;variable: objeto instanciado de la clase [[String]] ;valor: Carácter o cadena a buscar dentro del objeto ([[char]], [[string]] o [[String]]). ;desde: Permite buscar una coincidencia desde cierta posición, aunque el recorrido se realiza para atrás. == Retorna == La posicion hallada, o -1 si no lo encuentra ([[int]]). == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:String]] 85cls6j63n90uoomqi03p2egivezzy2 0 346 3614 3613 2019-05-06T18:14:22Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Retorna la longitud (en cantidad de caracteres) actual de esta cadena. == Sintaxis == <pre> objeto.length(); </pre> == Parámetros == ;objeto: instancia de la clase [[String]]. == Retorna == La longitud de la cadena ([[int]]). == Advertencias == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> String cadena = "Apuntes de Arduino"; cadena.length(); //18 </syntaxhighlight> == Ejemplo 2 == En este ejemplo debes enviar una frase por la consola por ejemplo "Hola mundo". <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ if (Serial.available()) { String texto = Serial.readString(); Serial.println(texto.length()); } }</syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [http://arduino.cc/en/Reference/StringLength Guia de referencia Arduino] [[Category:String]] ag9r947e21n8trlqh4hsl2pdnjqh7sw 0 349 3618 3617 2019-05-06T18:15:39Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Remueve (elimina) una porción de la cadena. == Sintaxis == <pre> objeto.remove(indice); objeto.remove(indice, conteo); </pre> == Parámetros == ;objeto: nombre de la instancia de la clase [[String]]. ;indice: la posición inicial a tomar en cuenta ([[int]]). ;conteo: la cantidad de caracteres a eliminar desde la posición inicial ([[int]]). == Retorna == Nada. == Advertencias == Si remueves desde '''0''' [[objeto.length()]] caracteres, efectivamente estarías vaciando (borrando) la cadena completa. Sin embargo, sería más eficiente asignarle "" en vez de hacerlo de manera antes descrita. == Ejemplo == <syntaxhighlight lang="c++"> String saludo = "hello"; saludo.remove(2, 2); //heo </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/remove/ Guia de referencia de Arduino] [[Category:String]] becyydnc3rgsx0z25xdrmrsgl7y5k8m 0 345 3616 3615 2019-05-06T18:15:07Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Este método le permite reemplazar todas las instancias de una cadena dada por otra cadena. Puede tratarse de cadenas (con comillas doble) o caracteres simples (con comillas simple). == Sintaxis == <pre> objeto.replace(cadena1,cadena2); </pre> == Parámetros == ;objeto: nombre de la instancia del objeto [String] ;cadena1: una variable de tipo [[String]] o valor en comillas dobles si son varios caracteres. ;cadena1: otra variable de tipo [[String]] o valor en comillas dobles si son varios caracteres. == Retorna == Nada. == Advertencias == * Los caracteres debe ser encerrados con comillas simples. * El conjunto de caracteres de una cadena deben ser encerrados en comillas dobles. == Ejemplo == <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); Serial.println("Reemplazar una cadena:"); } void loop() { String cadena = "Pata Peta Pita Pota"; Serial.println("Cadena original: " + cadena); //Cambia todas las instancias de una subcadena con otra cadena.replace("ta","rir"); Serial.println("Cadena modificada: " + cadena); cadena = "Tata Teta Tita Tota Tuta"; Serial.println("Cadena original: " + cadena); //También puedes usar replace() en caracteres individuales: cadena.replace('T','P'); Serial.println("Cadena modificada: " + cadena); //No hacer nada mientras sea verdadero while (true); } </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/replace/ Guia de referencia de Arduino] [[Category:String]] tcc3i83q9dleijozl371tsduufa1h7t 0 362 3793 3792 2019-05-06T23:01:35Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Crea (o modifica) la reservación de espacio (en [[SRAM]]) para contener los caracteres de este objeto. En caso de ser para una variable global o [[static]], es buena práctica pre-asignar el espacio que se considere requerido; para así disminuir las posibilidades de fragmentar la memoria y mejorar el rendimiento al operar con este objeto. == Sintaxis == <pre> objeto.reserve(s); </pre> == Parámetros == ;objeto: nombre de la instancia de la clase [[String]]. ;s: espacio en número de caracteres a asignar ([[unsigned int]]). == Retorno == Nada. == Advertencias == No se debe confundir el tamaño del "contenedor" con la cantidad de caracteres que componen la cadena. Por lo tanto, '''reserve()''' no debería alterar inmediatamente el valor de [[objeto.length()]] a menos que el tamaño a reservar sea menor. == Ejemplos == <syntaxhighlight lang="c++"> String cadena; void setup() { Serial.begin(9600); cadena.reserve(26); cadena = "i="; cadena += "123"; cadena += ", esto es ok ?"; Serial.println(cadena); } void loop() { //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/reserve/ Guia de referencia Arduino] [[Category:String]] 1ck2sm4qsv8g7yzgtpf2v7p8mdhfb5q 0 339 3626 3625 2019-05-06T18:18:21Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Establece un carácter de la cadena. No tiene efecto en los índices fuera de la longitud existente de la cadena. == Sintaxis == <pre> objeto.setCharAt(indice,c); </pre> == Parámetros == ;objeto: nombre de la instancia de la clase [[String]] ;indice: el índice dónde cambiar el caracter ([[int]]) ;c: el caracter a colocar en la ubicación dada ([[char]]). == Retorna == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/setcharat/ Guia de referencia de Arduino] [[Category:String]] fh3zn35pjnlahn8tku650ljkdmfb0ba 0 353 3632 3631 2019-05-06T18:20:26Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Comprueba si un objeto comienza con los caracteres de otra cadena. == Sintaxis == <pre> objeto.startsWith(cadena); </pre> == Parámetros == ;objeto: nombre de la instancia de la clase [[String]] ;cadena: variable tipo [[String]] == Retorna == ;true: Si el objeto empieza con la cadena. ;false: Lo contrario. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); Serial.println("Ejemplos con: startsWith() y endsWith():"); } void loop ( ) { String cadena = "HTTP / 1.1 200 OK"; Serial.println(cadena); //Comprueba si comienza con una cadena particular if (cadena.startsWith("HTTP / 1.1")) { Serial.println("El servidor usa http versión 1.1"); } //Buscar en una posición de desplazamiento en la cadena if (cadena.startsWith("200 OK",9)){ Serie.println("Obtuve un OK del servidor"); } //Comprueba si un objeto termina con un caracter en particular String sensor = "sensor = "; sensor += analogRead(A0); Serial.print(sensor); if (sensor.endsWith("0")) { Serial.println(". Esta lectura es divisible por diez."); }else{ Serial.println(". Esta lectura no es divisible por diez."); } //No hacer nada mientras sea verdadero: while (true) ; } </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/startswith/ Guia de referencia de Arduino] [[Category:String]] 604wu7v189pdbcqj0ejrheklfk8nz6s 0 337 3597 3596 2019-05-06T18:05:03Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Extrae una cadena de caracteres entre dos posiciones. == Sintaxis == <pre> objeto.substring(desde); objeto.substring(desde, hasta); </pre> == Parámetros == ;objeto: instancia de la clase [[String]]. ;desde: Posición '''desde''' donde inicia la extracción de la subcadena ([[int]]). ;hasta: Posición '''hasta''' donde concluye la extracción de la subcadena ([[int]]). Si no se especifica, se irá hasta el final. == Retorna == Subcadena entre las posiciones desde y hasta ([[String]]). == Advertencias == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> String frase = "Apundes de Arduino"; frase.substring(10); //Arduino frase.substring(10,14); //Ardu </syntaxhighlight> == Ejemplo 2 == En este ejemplo ponemos en e monitor serie algo como: 123,456,789 y obtendremos 456.00 el numero entre las , en [[float]] <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); } void loop() { String num = ""; while (Serial.available()){ char c = Serial.read(); num = num + c; delay(10); } if (num != ""){ byte pos1 = num.indexOf(",") +1; byte pos2 = num.indexOf(",",pos1); float n = num.substring(pos1,pos2).toFloat(); Serial.println(n); } } </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:String]] cf89yvgay90led8pgz0fopogcwo8k64 0 350 3593 3592 2019-05-06T18:03:51Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Copia los caracteres del objeto al buffer provisto. == Sintaxis == <pre> objeto.toCharArray(matriz, largo); </pre> == Parámetros == ;objeto: Nombre del objeto instanciado de la clase [[String]]. ;matriz: Variable matriz tipo [[char]] donde se copiaran los caracteres. ;largo: Tamaño del búfer tipo [[unsigned int]]. Lo puedes sacar de [[objeto.length()]] == Retorna == Nada. == Advertencias == La longitud del buffer debe respetarse, de lo contrario se corre el riesgo de un "desbordamiento de buffer" que puede corromper el contenido la memoria de ejecución ([[SRAM]]). == Ejemplo == Aqui tenemos una cadena con 4 caracteres, creamos una matriz del tamaño adecuado y volcamos contenido con '''toCharArray()''' luego comprobamos con un simple for. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); String cadena = "abcd"; char matriz[cadena.length()]; cadena.toCharArray(matriz, cadena.length()); for (byte i=0; i<=cadena.length(); i++){ Serial.println(matriz[i]); delay(100); } } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/tochararray/ Guia de referencia de Arduino] [[Category:String]] m7up0l9kqnebyjom7vdcl19wrwun06w 0 351 4912 3599 2019-09-20T15:38:11Z Kike GL 2 /* Ejemplo 2 */ wikitext text/x-wiki == Descripción == Convierte una objeto válido en un numero tipo [[float]]. La cadena de entrada debe comenzar con un dígito. Si la cadena contiene caracteres que no son dígitos, el método dejará de realizar la conversión. == Sintaxis == <pre> objeto.toFloat(); </pre> == Parámetros == ;objeto: nombre de la instancia de la clase [[String]] == Retorna == El valor convertido ([[float]]), o '''0.0''' en caso de que la cadena no empiece con una secuencia válida. == Comentarios == Por ejemplo, las cadenas "123.45", "123" y "123fish" se convierten a 123.45, 123.00 y 123.00 respectivamente. Tenga en cuenta que "123.456" se aproxima a 123.46. == Advertencias == Tenga en cuenta también que los numero [[float]] tienen solo 6-7 dígitos decimales de precisión y que las cadenas más largas pueden estar truncadas. == Ejemplo 1 == Convertimos una cadena de dígitos en [[float]]. <syntaxhighlight lang="c++"> String texto = "-123.45"; void setup(){ Serial.begin(115200); float valor = texto.toFloat(); Serial.println(valor); } void loop(){ //Nada. } </syntaxhighlight> == Ejemplo 2 == En este ejemplo pondremos en el monitor serie algo como: 123,456,789 y veras como respuesta 456.00 osea el numero entre las , en [[float]]. <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); } void loop() { String num = ""; while (Serial.available()){ char c = Serial.read(); num = num + c; delay(10); } if (num != ""){ byte pos1 = num.indexOf(",") +1; byte pos2 = num.indexOf(",",pos1); float n = num.substring(pos1,pos2).toFloat(); Serial.println(n); } } </syntaxhighlight> == Ejemplo 3 == En este ejemplo pondremos en el monitor serie algo como: 123.456 y veras como respuesta 123.45 osea el numero en [[float]]. <syntaxhighlight lang="c++"> String frase = ""; float x; void setup(){ Serial.begin(9600); } void loop(){ while (Serial.available()){ char caracter = Serial.read(); frase.concat(caracter); delay(10); } if (frase != ""){ x = frase.toFloat(); Serial.println(x); frase = ""; } } </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/tofloat/ Guia de referencia de Arduino] * [https://www.luisllamas.es/convertir-texto-a-numero-arduino/ Convertir texto a numero] - Luis Llamas [[Category:String]] 0t9eoid6nmwvwcujrzcfcuyqgnu9gdx 0 179 3595 3594 2019-05-06T18:04:27Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Convierte una cadena válida en un entero. La cadena de entrada debe comenzar con un número entero. Si la cadena contiene números no enteros, la función dejará de realizar la conversión. == Sintaxis == <pre> objeto.toInt(); </pre> == Parámetros == ;objeto: nombre de la instancia de la clase [[String]]. == Retorna == El valor convertido ([[long]]), o '''0''' en caso de que la cadena no empiece con una secuencia válida. == Advertencias == Nada. == Ejemplo 1 == Si envias digitos por la consola se convierten en entero. <syntaxhighlight lang="c++"> String cadena = ""; void setup(){ Serial.begin(9600); Serial.println("Cadena toInt():"); } void loop() { while (Serial.available()) { char caracter = Serial.read(); if (isDigit(caracter)) { //Solo concatena si es dígito cadena += caracter; } //si obtiene una nueva línea, imprima la cadena, luego el valor de la cadena if (letra == '\n') { Serial.print("Valor:") ; Serial.println(cadena.toInt()); Serial.print("Cadena:"); Serial.println(cadena); cadena = "" ; //Limpia cadena para proxima lectura } } } </syntaxhighlight> == Ejemplo 2 == Definida una cadena se convierte a [[int]]. <syntaxhighlight lang="c++"> String texto = "-12345"; void setup(){ Serial.begin(115200); int entero = texto.toInt(); Serial.println(entero); } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 3 == En este ejemplo ponemos en el monitor serie algo como: 123,456,789 y obtendremos 456 el numero entre las , es [[int]]. <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); } void loop() { String num = ""; while (Serial.available()){ char c = Serial.read(); num = num + c; delay(10); } if (num != ""){ byte pos1 = num.indexOf(",") +1; byte pos2 = num.indexOf(",",pos1); int n = num.substring(pos1,pos2).toInt(); Serial.println(n); } } </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/StringToInt Guia de referencia de Arduino] * [https://www.luisllamas.es/convertir-texto-a-numero-arduino/ Convertir texto a numero] - Luis Llamas [[Category:String]] 1m4m2kmrqkvmllxzwjetsj4rmyadog2 0 343 3604 3603 2019-05-06T18:08:16Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Pasa a minusculas todos los caracteres de la cadena. == Sintaxis == <pre> objeto.toLowerCase(); </pre> == Parámetros == ;objeto: instancia de la clase [[String]]. == Retorna == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> String frase = "Apuntes de Arduino"; frase.toLowerCase(); //apuntes de arduino </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:String]] 7mn0esk8o3k8l85f6px8l5p58fl5sb2 0 344 3634 3633 2019-05-06T18:21:06Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Cambia a mayusculas todos los caracteres de la cadena. == Sintaxis == <pre> objeto.toUpperCase(); </pre> == Parámetros == ;objeto: instancia de la clase [[String]]. == Retorna == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> String frase = "Apuntos de arduino"; frase.toUpperCase(); //APUNTES DE ARDUINO </syntaxhighlight> == Vea también == <categorytree mode=all>String</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:String]] 0dv4mz4dztz0zlas4od5cji50ztvggi 0 352 3606 3605 2019-05-06T18:09:26Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Crea una versión de la cadena con cualquier espacio en blanco inicial y final eliminado. A partir de 1.0, '''trim()''' modifica la cadena en lugar de devolver una nueva. == Sintaxis == <pre> objeto.trim(); </pre> == Parametros == ;objeto: Instancia de la clase [[String]] == Retorna == Nada. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> String frase = " Apuntes de Arduino "; frase.trim(); //"Apuntes de Arduino" </syntaxhighlight> == Vea también == <categorytree mode=all>Stream</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:String]] mzhzrnxykowkyifbq528mjij041caoi 0 98 5295 5294 2020-06-06T21:39:43Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Es un operador boleano '''or''' <nowiki>||</nowiki> que permite unir dos expresiones lógicas de manera disyuntiva ("o"). Sus posibles resultados son dados por la siguiente tabla de verdad: {| class="wikitable col3cen" !a!!b!!a <nowiki>||</nowiki> b |- |0||0||0 |- |1||0||1 |- |0||1||1 |- |1||1||1 |} == Sintaxis == <pre> espresion 1 or expresion 2 espresion 1 || expresion 2 </pre> == Retorna == Verdadero o falso. == Advertencias == * No confundir el operador boleano '''or''' (<nowiki>||</nowiki>), con el operador [[or bit a bit]] (<nowiki>|</nowiki>). == Ejemplo == <syntaxhighlight lang="c++"> if (x < 9 || x > 20){ //Esta fuera del rango }else{ //Esta entre 10 y 19 } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador logico</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [https://programarfacil.com/blog/programacion/la-logica-en-la-programacion/ La lógica en la programacion] - Luis Del Valle * [https://aprendiendoarduino.wordpress.com/category/operadores/ Operadores] - Aprendiendo Arduino [[Category:Operador logico]] 9bemk8gdb10lo73yqdt2xt62a2c71sg 0 208 4986 4976 2019-09-26T23:26:29Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == El operador binario '''OR bit a bit''' es representado por el carácter barra <nowiki>|</nowiki>. OR establece (pone en 1) un bit sí y solo si el bit de esa posición está establecido (en 1) en al menos uno de los operandos. {| class="wikitable col3cen" !a!!b!!a <nowiki>|</nowiki> b |- ||0||0||0 |- ||0||1||0 |- ||1||0||0 |- ||1||1||1 |} {{Nota|Esta operación también es usada para establecer (poner en uno) uno o varios bits específicos en una variable. Todo bit en 1 en el segundo operando, se establecerá; mientras que todo bit en cero se se quedará como está.}} == Sintaxis == <pre> op1 | op2 </pre> ;op1: primer operando, es la variable (de cualquier tipo) a modificar. ;op2: segundo operando, es quien va a relizar las modificaciones pertinentes. == Retorno == El valor resultante, donde cada bit se establece sólo si lo está en al menos uno de los operandos. == Advertencias == * No confundir este operador '''OR bit a bit''' <nowiki>|</nowiki> con el boleano [[or]] <nowiki>||</nowiki> * Idealmente ambos operandos deberían ser del mismo tipo (tamaño); en caso de no ser así, solo se operará con los bytes menos significativos del más grande. == Ejemplo == <syntaxhighlight lang="c++"> byte var = 1; var |= B00000110; //Ahora var vale 7 debido a que establecí esos bits </syntaxhighlight> == Vea también == * [[not]] <nowiki>(!)</nowiki> * [[and]] <nowiki>(&&)</nowiki> * [[or]] <nowiki>(||)</nowiki> * [[not bit a bit]] <nowiki>(~)</nowiki> * [[and bit a bit]] <nowiki>(&)</nowiki> * [[xor bit a bit]] <nowiki>(^)</nowiki> * [[bitshift right]] <nowiki>(>>)</nowiki> * [[bitshift left]] <nowiki>(<<)</nowiki> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [https://playground.arduino.cc/Code/BitMath/#bitwise_or Bitwise OR] - Playgroubd [[Category:Operador bit a bit]] rnn0p8ttb399njxq7jhq9b3k2xf4eps 0 218 5021 5020 2019-09-27T00:06:56Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == El operador '''OR bit a bit compuesto''' (|=) se usa para forzar cierto bit de una variable a 1 (HIGH). {| class="wikitable col3cen" !a!!b!!a <nowiki>|=</nowiki> b |- |0||0||0 |- |1||0||1 |- |0||1||1 |- |1||1||1 |} {{Nota|A menudo se hace referencia en las guías de programación como "puesta a 1" (SET) de bits.}} == Sintaxis == <pre> variable |= mascara; variable = variable | mascara; </pre> == Parámetros == ;variable: Nombre de la variable a operar. Puede ser tipo: [[char]], [[byte]], [[int]] o [[long]] ;mascara: constante entera. Puede ser tipo: [[char]], [[byte]], [[int]] o [[long]] == Retorno == * Los bits tratados con 0 no se modifican. Mantienen su estado. * Los bits tratados con 1 se ponen a 1, sin importar su estado. == Comentarios == debido a que se trata de bits de un operador de bits - es conveniente usar el formateador binario con constantes. Las cifras siguen siendo el mismo valor en otras representaciones, que simplemente no son tan fáciles de entender. Además, B00000000 se muestra por claridad, pero cero en cualquier formato de número es cero. == Advertencias == Nada. == Ejemplo 1 == Para configurar los bits 0 (menos significativo) y 1 de una variable, dejando el resto de la variable sin cambios, use el operador '''OR bit a bit compuesto''' (| =) con la constante B00000011. <syntaxhighlight lang="c++"> byte a = B10101010; a |= B00000011; //B10101011 </syntaxhighlight> {|class="wikitable" |Variable||Bxxxxxxxx |- |Mascara||B00000011 |- |Resultado||Bxxxxxx11 |} == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); int z,n = 12345; byte val1 = highByte(n); byte val2 = lowByte(n); z = val1; //Tomamos MSB z <<= 8; //Desplazamos 8 bits a la izquierda z |= val2; //Añadimos LSB} Serial.println(z); } void loop(){ //Nada } </syntaxhighlight> == Vea también == * [[incremento]] <nowiki>(++)</nowiki> * [[decremento]] <nowiki>(--)</nowiki> * [[suma compuesta]] <nowiki>(+=)</nowiki> * [[resta compuesta]] <nowiki>(-=)</nowiki> * [[multiplicacion compuesta]] <nowiki>(*=)</nowiki> * [[division compuesta]] <nowiki>(/=)</nowiki> * [[modulo compuesto]] <nowiki>(%=)</nowiki> <categorytree mode=all>Operador bit a bit compuesto</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias externas == * [https://manueldelgadocrespo.blogspot.com/p/or-bit-bit-compuesto.html Manuel Delgado Crespo] [[Category:Operador bit a bit compuesto]] h8mxksu830j02z2kbre6ox3z5n7ufl7 0 25 4644 4347 2019-07-04T16:46:27Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Esta función debe ser usada dentro de [[setup()]] y sirve para configurar los puertos digitales que serán usadas y el modo que puede ser INPUT (entrada) o OUTPUT (salida) o INPUT_PULLUP (entrada con resistencia pull-up interna). {{Tip|Los pines tanto analógicos como digitales de '''entrada''' no necesitan ser definidos con '''pinMode()'''.}} == Sintaxis == <pre> pinMode(pin, modo); </pre> == Parámetros == ;pin: es el numero del pin digital a usar (0~13 + 14~19). Puedes usar [[const]] [[byte]] para definirla. ;modo: por lo general se usa las palabras reservadas: [[INPUT / OUTPUT / INPUT_PULLUP]]. == Retorna == Nada. == Comentarios == * Los terminales de Arduino, por defecto, están configurados como entradas, por lo tanto no es necesario definirlos en el caso de que vayan a trabajar como entradas. * Los pines configurados como INPUT (entrada) quedan, bajo el punto de vista eléctrico, como entradas en alta impedancia. * Los pines configurado como OUTPUT (salida) se dice que están en un estado de baja impedancia y pueden proporcionar 40 mA de corriente a otros dispositivos y circuitos. Esta corriente es suficiente para alimentar un LED (no olvides poner una resistencia en serie de 220 ohms o mas), pero no es lo suficiente grande como para alimentar cargas de mayor consumo como relés o motores. * Un cortocircuito en las patillas Arduino provocará una corriente elevada que puede dañar o destruir el chip ATmega. == Advertencias == En muchos ejemplos se ve que usa una variable de tipo [[int]] para definir el pin a usar. Esto es un grave error por dos motivos: # Una variable sera almacenada en memoria [[SRAM]] porque se espera que su valor cambie durante la ejecución del [[boceto]], pero normalmente en los pines esto nunca ocurre, por lo que es preferible usar [[const]] que es almacenada en [[flash]]. # El tipo [[int]] ocupa 2 byte. Es suficiente usar el tipo [[byte]] (0~255) que solo ocupa 1 byte. == Ejemplo 1 == Aqui definimos los pines digitales 3, 4 y 5 como salidas. <syntaxhighlight lang="c++"> void setup(){ for (byte n=3; n<=5; n++){ pinMode(n, OUTPUT); } } void loop(){ //nada } </syntaxhighlight> == Ejemplo 2 == Usamos un pin analogico como digital. <syntaxhighlight lang="c++"> void setup() { pinMode(A0, OUTPUT); //Definimos pin analógico A0 como digital. También funciona con 14. digitalWrite(A0, HIGH); } void loop() { //Nada } </syntaxhighlight> == Ejemplo 3 == Parpadea el LED a bordo. <syntaxhighlight lang="c++"> void setup() { DDRB = DDRB | 32; //Configura el pin digital 13 como OUTPUT, no altera el resto. 32=B00100000; } void loop() { PORTB = PORTB ^ 32; //Invertido estado del bit 5 (pin digital 13), no altera el resto. delay(500); } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones pines</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/variables/constants/constants/ Niveles lógicos en Arduino] * [https://playground.arduino.cc/ArduinoNotebookTraduccion/DigitalIO Playground] * [https://www.prometec.net/funciones1/ Funciones Arduino] - Prometec * [https://programarfacil.com/podcast/26-arduino-entradas-y-salidas/ Entradas y salidas] - Luis del Valle * [http://manueldelgadocrespo.blogspot.com/p/pinmode.html pinMode()] - Manuel Delgado [[Category:Funciones pines]] oj9784c3k1abbe7ws0kdvq6f1di4n4g 0 169 5299 5166 2020-06-06T21:43:37Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Calcula el valor de un número elevado a una potencia. Se puede usar para elevar un número a una potencia fraccionaria. Esto es útil para generar un mapeo exponencial de valores o curvas. == Sintaxis == <pre> pow(base,exponente); </pre> == Parámetros == ;base: numero base. Tipo [[float]] ;exponente: exponente. Recuerda que 0.5 es raiz cuadrada. Tipo [[float]] == Retorno == Retorna el numero base elevado al exponente. Tipo [[double]] == Advertencias == Nada. == Ejemplos == <syntaxhighlight lang="c++"> pow(3,3); //81 pow(9,0.5); //3 </syntaxhighlight> == Vea también == * [[abs()]] * [[constrain()]] * [[map()]] * [[max()]] * [[min()]] * [[sq()]] * [[sqrt()]] * [[log()]] * [[ceil()]] * [[floor()]] == Referencias == * [https://www.arduino.cc/reference/en/language/functions/math/pow/ pow()]- Referencia Arduino * [https://www.prometec.net/funciones1/ Funciones] - Prometec * [https://www.prometec.net/funciones1/ Aprendiendo Arduino] - Enrique Crespo * [http://manueldelgadocrespo.blogspot.com/p/powbase-exponent.html Arduino en español] - Manuel Delgado [[Category:Funciones matematicas]] 2nbftib62sjsaxk3slkwrhsmbunx1ob 0 182 4280 4240 2019-06-11T23:28:34Z Kike GL 2 /* Vea tambien */ wikitext text/x-wiki == Descripción == Lee un pulso (HIGH o LOW) en un pin digital y retorna la duración del pulso en microsegundos o 0 si no se inicia ningún pulso dentro de un tiempo de espera especificado. La función '''pulseIn()''' espera que el pin pase a HIGH, inicia el cronometraje, luego espera que el pin pase a LOW y detiene el cronometraje. {{Nota|Funciona bien con pulsos desde 10 us a 3 min de duración.}} == Sintexis == <pre> pulseIn(pin, valor); pulseIn(pin, valor, espera); </pre> == Parámetros == ;pin: numero de pin digital a examinar. ;valor: es el tipo de pulso a identificar: HIGH o LOW. ;espera: es el numero de us que espera el pulso. El predeterminado es 1 segundo. == Retorna == Retorna la longitud del pulso en microsegundos en [[unsigned long]] o 0 si el pulso no se completa dentro del tiempo de espera determinado con "espera". == Advertencias == Nada. == Ejemplo == Para este ejemplo conecta un pulsador entre el pin 7 y GND. Luego de pulsar y soltar, Arduino te dirá la duración del pulso en microsegundos. <syntaxhighlight lang="c++"> unsigned long duracion = 0; void setup(){ Serial.begin(9600); pinMode(7, INPUT_PULLUP); } void loop(){ duracion = pulseIn(7, LOW); if (duracion){ Serial.print("Tiempo (us) = "); Serial.prinln(duracion); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones tiempo</categorytree> == Referencias externas == [[Category:Funciones tiempo]] f06auty37uocuaeuru4scc3oswspan5 0 444 3865 2019-05-08T14:46:57Z Kike GL 2 Kike GL trasladó la página [[pulseln()]] a [[pulseIn()]] wikitext text/x-wiki #REDIRECCIÓN [[pulseIn()]] ldsbknum3tjpjgyld216abxe24xum1m 0 48 4153 2359 2019-06-11T19:39:14Z Kike GL 2 /* Retornos */ wikitext text/x-wiki == Descripción == La función random devuelve un número aleatorio entero de un intervalo de valores especificado entre los valores min (inclusive) y max (hasta max-1). {{Nota|Si quiere realmente generar un número aleatorio entre una ejecución y otra, debe cambiar el valor de la "semilla" con [[randomSeed()]].}} == Sintaxis == <pre> random(max); random(min, max); </pre> == Parámetros == ;max: numero maximo pero no lo incluye. Hasta max-1 ;min: numero minimo incluido (cero cuando no se especifica este parámetro). == Retornos == Retorna un número aleatorio entero tipo [[long]], cuyo valor oscilará entre '''min''' y '''max'''-1. == Comentarios == {{Tip|Este comando tarda 2245 ciclos de CPU.}} == Advertencias == Es un generador pseudo-aleatorio, lo que quiere decir que si la semilla (valor de iniciación) permanece constante, la secuencia de valores generados también lo será. Hay dos formas de obtener la semilla en tiempo de ejecución y con relativa aleatoriedad: # El valor retornado por [[analogRead()]] sobre un pin analógico "flotante" (libre, sin conectar a nada), aunque la semilla estaría limitada a la resolución del ADC. # Una técnica que involucra aprovechar el desfase natural entre el oscilador principal y el del temporizador "watchdog", pulsar [https://gist.github.com/endolith/2568571 aquí] para leer sobre el tema (en inglés y aplica únicamente para arquitecturas AVR). == Ejemplo == <pre> byte n = random(0,256); //Genera un numero entre 0~255 (max-1) int n = random(1024); //Genera un numero entre 0~1023 </pre> == Vea también == * [[randomSeed()]] == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones]] jj3q5kf5zqvls0c7pirpwdr0msbavom 0 223 2358 1507 2018-08-10T02:22:02Z Lucario448 3 /* Advertencias */ wikitext text/x-wiki == Descripción == Establece un valor, o semilla, como punto de partida para la función [[random()]]. En realidad inicializa el generador de números pseudoaleatorios, haciendo que comience en un punto arbitrario en su secuencia aleatoria. Esta secuencia, aunque es muy larga y aleatoria, siempre es la misma. <pre> void setup(){ randomSeed(semilla); } </pre> == Parámetros == ;semilla: un numero tipo [[unsigned long]] que define la semilla. == Retorno == Nada. == Advertencias == * Si llamas esta función con un numero [[unsigned long]] fijo la secuencia [[random()]] siempre se repetira. == Comentarios == * Si el pin A0 esta al aire producirá ruido que es perfecto para usar de semilla. == Ejemplos == <syntaxhighlight lang="c++"> void setup(){ randomSeed(analogRead(A0)); } void loop(){ int aleatorio = random(1024); //Numero entre 0~1023 } </syntaxhighlight> == Vea también == * [[random()]] == Referencias == [[Category:Funciones]] 5gjlep9inll8ykqz4fnmgdc736faesn 0 370 4846 2029 2019-07-25T00:53:16Z Kike GL 2 /* Advertencias */ wikitext text/x-wiki == Descripción == == Sintaxis == <pre> </pre> == Parámetros == == Retorno == == Comentarios == == Advertencias == Nada. == Ejemplo == <pre> </pre> == Vea también == * [[free()]] * [[malloc()]] * [[calloc()]] == Referencias == [[Category:Funciones]] r3z4h16wykab7ghxdunk8wvx7t7ce3v 0 92 5031 4720 2019-09-27T00:19:21Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == La resta es una de las cuatro operaciones aritméticas primarias. El operador -(menos) opera en dos operandos para producir la diferencia entre el segundo y el primero. == Sintaxis == <pre> op1 - op2 </pre> ;op1: primer operando, también conocido como el minuendo. ;op2: segundo operando, también conocido como el sustraendo. == Advertencias == * Al hacer operaciones aritméticas preste atención a los tipo de dato involucrados. * Debido a que toda variable tiene un límite, una resta que resulte en un valor extremedamente bajo puede tener un resultado sin sentido (por desbordamiento). Por ejemplo: que una resta de un entero negativo con otro positivo resulte en un valor positivo (si la variable es con signo), o que sea mayor que el primer operando (si la variable es sin signo y el segundo operando es positivo). == Ejemplo == <pre> int x = 10; int y = 5; x = x - 3; //7 x--; //6 (decremente x en uno) x -= y; //1 (decremente x en y, lo mismo que hacer x = x - y:) </pre> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/structure/arithmetic-operators/subtraction/ Guia de referencia de Arduino] * [https://aprendiendoarduino.wordpress.com/2018/04/08/operadores-5/ Aprendiendo Arduino] [[Category:Operador aritmetico]] n1x7sl5czbk37l5p3y59yxzn3fhsun9 0 214 5013 5007 2019-09-26T23:58:22Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Resta un valor de una variable y guarda el resultado en la misma variable. {{Tip|Es lo mismo que variable <nowiki>=</nowiki> variable - valor.}} == Sintaxis == <pre> variable -= valor; variable = variable - valor; </pre> == Parámetros == ;variable: Nombre de la variable a operar. Puede ser de cualquier tipo: [[char]], [[byte]], [[int]], [[long]], [[float]]. ;valor: Valor del mismo tipo que variable. == Retorno == Retorna la variable decrementada en valor. == Advertencias == Tenga cuidado con no provocar desborde u obtendrá resultados inesperados. == Ejemplo 1 == En el caso de datos o variables numéricas se efectúa la '''resta''' y el resultado se guarda en misma variable. <syntaxhighlight lang="c++"> byte n = 15; n -= 3; //12 n -= 3; //9 </syntaxhighlight> == Ejemplo 2 == En este ejemplo nos hemos atrevido a usar el decremento sobre una variable tipo [[char]] Se muestra Z, U, P, K, F, A. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); char x = 'Z'; Serial.println(x); for (byte n=0; n<5; n++){ x -= 5; Serial.println(x); } } void loop(){ } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias == [[Category:Operador aritmetico compuesto]] 9l21ms92p22b3k1bo6vwcwt1l2bne2z 0 89 5256 5255 2020-02-04T12:52:08Z Kike GL 2 /* Ejemplo 2 */ wikitext text/x-wiki == Descripción == Termina una función, devuelve el control y opcionalmente un valor desde una función a la función que la llamó. {{Nota|Lo que escribamos por debajo de '''return''' en la función donde lo usemos, no se ejecutará nunca. Ya que, cuando llega a '''return''', vuelve a la función que lo llamó.}} == Sintaxis == <pre> return [variable]; </pre> == Parámetros == ;variable: variable, constante o valor que se retornara. == Retorno == Valor de la variable o constante a la función invocadora (si no es de retorno la funcion debera ser definida con [[void]]). == Advertencias == * Al crear la función debes indicar el tipo de valor retornado. * Solo se usa [[void]] para las funciones que NO retornan ningun valor. == Ejemplo 1 == Con esta funcion convertimos un sensor analogo en digital. <syntaxhighlight lang="c++"> bool checkSensor(){ if (analogRead(0) > 400) { return true; }else{ return false; } } </syntaxhighlight> == Ejemplo 2 == Esta funcion retorna valores simplificados entre 0 y 10. Recuerda que n sera entre 0 y 1023. <syntaxhighlight lang="c++"> byte sensor(){ int n = analogRead(5); return n%100; } </syntaxhighlight> == Vea también == * [[if... else]] * [[Asignación condicional]] * [[switch... case]] * [[for]] * [[while]] * [[do... while]] * [[break]] * [[continue]] * [[goto]] == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Estructura control]] p939ynbuultxewyetehb85xbr7imkm6 0 296 4821 4820 2019-07-19T00:14:05Z Kike GL 2 /* Ejemplos */ wikitext text/x-wiki == Descripción == Esta funcion se invoca cuando hay datos disponibles en el buffer del puerto serie. == Sintaxis == <pre> void serialEvent(){ //Comandos } </pre> == Parámetros == ;comandos: cualquier declaración válida == Retorno == Verdadero si hay datos en el buffer. == Comentarios == * Lo puedes usar en [[UNO]], [[NANO]] y [[MEGA]]. * [[MEGA]] tiene un evento para cada puerto serie. == Advertencias == * Actualmente, '''serialEvent()''' no es compatible con [[ESPLORA]], [[Leonardo]] ni [[MICRO]]. == Ejemplos == Para Arduino [[UNO]] y [[NANO]]. <syntaxhighlight lang="c++"> void serialEvent(){ //Comandos } </syntaxhighlight> == Ejemplo 2 == Solo para Arduino [[MEGA]]. <syntaxhighlight lang="c++"> void serialEvent1(){ //Comandos } void serialEvent2(){ //Comandos } void serialEvent3(){ //Comandos } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == * [https://aprendiendoarduino.wordpress.com/tag/comunicacion-serie/ Comunicación serie] - Enrique Crespo [[Category:Serial]] ebpgnxr9pwb23dxt7t0x0critljuxgm 0 310 4811 4810 2019-07-19T00:06:08Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Llamado (a manera de rutina de interrupción) cada vez que se recibe un dato en el pin Rx; se ejecuta después de colocarlo en el buffer de entrada. Use [[Serial.read()]] para capturar esos datos. == Sintaxis == <pre> void serialEvent(){ //Algo } </pre> == Ejemplos == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == * [https://www.arduino.cc/en/Tutorial/SerialEvent serialEvent()] - Rerencias Arduino * [http://manueldelgadocrespo.blogspot.com/p/serialev.html serialEvent()] - Manuel Delgado * [https://aprendiendoarduino.wordpress.com/tag/comunicacion-serie/ Comunicacion serie] - Enrique Crespo * [https://www.prometec.net/funcionesii/ Funciones serie] - Prometec [[Category:Serial]] pq1lk53p326tlumniazep93jgry9u9g 0 395 3470 3050 2019-05-06T00:04:39Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripcion == La función '''setTime()''' esta disponible luego de invocada la libreria '''TimeLib.h''' y nos permite decirle al Arduino en que día y hora estamos y que a partir de allí mantenga adecuadamente esa fecha hasta su próximo reseteo. == Sintaxsis == <pre> setTime(ss); //Numero de segundos desde 1-ENE-1970 setTime(h,m,s,dia,mes,año); //hora, minuto, segundo dia, mes, año. </pre> == Parámetros == ;ss:Segundos transcurridos desde 1-ENE-1970 ;h:Hora (0~23) ;m:Minuto (0~59) ;s:Segundo (0~59) ;dia:Dia (1~31) ;mes:Mes (1~12) ;año:Año (1970~2069) == Comentarios == * Si necesitas hacer conversiones entre fecha y '''Unix Time Stamp''' usa [https://www.unixtimestamp.com/ Epoch Converter] * El formato '''Unix Time Stamp''' es muy util para hacer operaciones entre dos fechas. == Advertencias == Es indispensable incluir en el [[boceto]] '''#include <TimeLib.h>''' para que funcione o arrojara un error. == Ejemplo 1 == Creamos un reloj sin hardware externo y mostramos la h:m:s.milisegundos cada segundo usando un [[delay()]]. Las funciones estan vacias. <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(9600); //setTime(1531562400); //Unix Time Stamp setTime(10,0,0,14,7,2018); //Formato h,m,s,d,m,a } void loop(){ Serial.print(hour()); Serial.print(":"); Serial.print(minute()); Serial.print(":"); Serial.print(second()); Serial.print("."); Serial.println(millis()); delay(1000); } </syntaxhighlight> {{Nota|Mira la secuencia cada ves hay 1001 milisegundos mas. Es debido a que el tiempo continua corriendo.}} == Ejemplo 2 == En este ejemplo incluimos la fecha hora 2018-7-14 10:0:0 y mostramos su avance cada 1350 milisegundos. Cada ciclo consultamos la hora y la guardamos en una variable por lo que ahora todas las funciones usan exactamente la misma hora. <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(9600); //setTime(1531562400); //Unix Time Stamp setTime(10,0,0,14,7,2018); //Formato h,m,s,d,m,a } void loop(){ time_t t = now(); Serial.print(hour(t)); Serial.print(":"); Serial.print(minute(t)); Serial.print(":"); Serial.println(second(t)); delay(1350); } </syntaxhighlight> == Ejemplo 3 == Muestra Arduino como un reloj sin hardware externo. Se sincroniza por mensajes enviados por el puerto serie, muestra la fecha y hora cada segundo por consola y administra el LED incorporado. Debes enviar algo como T1531562400 (2018-7-14 10:00:00). <syntaxhighlight lang="c++"> #include <TimeLib.h> #define TIME_HEADER "T" //Encabezado de mensaje de sincronizacion void setup() { Serial.begin(115200); pinMode(13, OUTPUT); Serial.println("Esperando sincronizacion"); } void loop(){ if (Serial.available()) { sinc(); } if (timeStatus()!= timeNotSet) { printFecha(); } if (timeStatus() == timeSet) { digitalWrite(13, HIGH); //Esta sincronizado }else{ digitalWrite(13, LOW); //Requiere sincronizacion } delay(1000); } void printFecha(){ if (day() < 10){ Serial.print("0"); } Serial.print(day()); //dia Serial.print("-"); if (month() < 10){ Serial.print("0"); } Serial.print(month()); //mes Serial.print("-"); Serial.print(year()); //año Serial.print(" "); if (hour() < 10){ Serial.print("0"); } Serial.print(hour()); //hora Serial.print(":"); if (minute() < 10){ Serial.print("0"); } Serial.print(minute()); //minutos Serial.print(":"); if (second() < 10){ Serial.print("0"); } Serial.println(second()); //segundos } void sinc() { if (Serial.find(TIME_HEADER)) { unsigned long pctime = Serial.parseInt(); if (pctime >= 1357041600) { //1-ENE-2013 setTime(pctime); //Sincroniza reloj Arduino } } } </syntaxhighlight> == Ejemplo 4 == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria Time</categorytree> == Referencias == * [https://www.prometec.net/time-arduino/ Libreria Time] - Prometec [[Category:Libreria Time]] mux4td8677mtu1ddyhiejkh3kx05v8b 0 23 2162 1515 2018-07-24T22:36:33Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == La función '''setup()''' se invoca cuando se inicia un boceto. Úselo para inicializar variables, modos de pin, comenzar a usar bibliotecas, etc. La función '''setup()''' solo se ejecutará una vez, después de cada encendido o reinicio de la placa Arduino. == Sintaxis == <pre> void setup(){ //Configuracion aqui } </pre> == Advertencia == {{Nota|Es obligatorio que esta sentencia sea incluida en cada [[boceto]], aunque puede estar vacía.}} == Ejemplo == Las instrucciones contenidos en setup() solo se ejecutan una vez al arrancar la placa. Luego de resetear o retirar energia se vlvera a ejecutar una sola vez. <syntaxhighlight lang="c++"> const byte pulsador = 3; void setup(){ Serial.begin(115200); pinMode(LED_BULITIN, OUTPUT); pinMode(pulsador, INPUT_PULLUP); } void loop(){ //... } </syntaxhighlight> == Vea también == * [[loop()]] * [[void]] * [[IDE]] * [[boceto]] [[Category:Estructura]] 74ykvstqkllgr3hcv9vgeug0mxevaed 0 184 4704 4695 2019-07-14T17:43:40Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Recibe en un byte de datos un bit cada vez desde un pin. Comienza a partir del bit más significativo (más a la izquierda)(MSB) o menos significativo (más a la derecha)(LSB). Para cada bit, el pin de reloj pasa a nivel alto, el siguiente bit se lee de la línea de datos y a continuación el pin de reloj pasa a nivel bajo. == Sintexis == <pre> shiftIn(dataPin, clockPin, bitOrder); </pre> == Parámetros == ;dataPin: aqui pondrás el puerto a leer. ;clockPin: es el pin que comandara el cambio (reloj) ;bitOrder: puede ser MSBFIRST (Primero el bit más significativo) o LSBFIRST (Primero el bit menos significativo). == Retorna == Retorna el byte leido. == Advertencias == * Si vamos a interactuar con un dispositivo que está sincronizado por flancos de subida ([[RISING / FALLING|RISING]]), necesitamos asegurarnos de que el pin de reloj está en estado LOW antes de la primera llamada a '''shiftIn()''' con una llamada a digitalWrite(pinReloj, LOW). == Comentarios == * Esta es una aplicación por software; Arduino también proporciona un bus [[SPI]] que es la complementación por hardware, más rápida, pero sólo funciona en pines específicos. == Ejemplo == <syntaxhighlight lang="c++"> </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones bit y byte</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/en/language/functions/advanced-io/shiftin/ Guia de referencia] * [https://www.prometec.net/funciones1/ Funciones de Arduino] - Prometec [[Category:Funciones bit y byte]] 3lvq78fm265sqz7t03cd02j9ycdj4xo 0 185 5264 5263 2020-03-15T03:16:02Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Envia en un byte de datos un bit a cada vez por el pin indicado. Comienza a partir del bit más significativo (más a la izquierda)(MSB) o menos significativo (más a la derecha)(LSB) dependiendo del parámetro bitOrden. Cada bit se escribe a su vez en un pin de datos, después de lo cual un pulso de reloj se activa (pasa a nivel alto, y a continuación, a nivel bajo) para indicar que el bit está disponible. {{Nota|Si está interactuando con un dispositivo que está administrado por bordes ascendentes (RISING), deberá asegurarse de que el pin del reloj esté bajo antes de la llamada '''shiftOut()''', por ejemplo, con una llamada a [[digitalWrite()|digitalWrite(clockPin, LOW)]].}} == Sintexis == <pre> shiftOut(dataPin, clockPin, bitOrder, valor); </pre> == Parámetros == ;dataPin: el pin en el que se muestra cada bit [[int]] ;clockPin: el pin para alternar una vez que el dataPin se ha establecido en el valor correcto [[int]] ;bitOrder: qué orden desplazar los bits; ya sea MSBFIRST o LSBFIRST. (Bit más significativo primero, o, bit menos significativo primero) ;value: los datos para desplazarse. [[byte]] == Retorna == La función '''shiftOut()''' escribe en la salida 1 byte (8 bits) por lo que requiere una operación de dos pasos para valores de salida mayores que 255 osea variables de 2 bytes tipo [[int]]. == Advertencias == * Los dataPin y clockPin deben estar ya configurados como salida con [[pinMode()]]. == Ejemplo 1 == En este ejemplo conectamos un 74x595 con 7 LED. Vcc(16)=MR(10)=+5V, GND(8)=OE(13)=GND. <syntaxhighlight lang="c++"> const byte dataPin = 8; //Pin 14 de 74x595 const byte clockPin = 9; //Pin 11 de 74x595 const byte latchPin = 10; //Pin 12 de 74x595 void setup() { pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, OUTPUT); } void loop() { for (byte i=0; i<256; i++) { digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, i); digitalWrite(latchPin, HIGH); //Muestra delay(500); } } </syntaxhighlight> == Ejemplo 2 == En este ejemplo conectamos un 74x595 con un display 7 segmentos de cátodo comun. Vcc(16)=MR(10)=+5V, GND(8)=OE(13)=GND. <syntaxhighlight lang="c++"> const byte dataPin = 8; //Pin 14 de 74x595 const byte clockPin = 9; //Pin 11 de 74x595 const byte latchPin = 10; //Pin 12 de 74x595 const byte dig[10]={ 252, //0 96, //1 218, //2 242, //3 102, //4 182, //5 190, //6 224, //7 254, //8 230 //9 }; void setup() { pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, OUTPUT); } void loop() { for (byte i=0; i<10; i++) { digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, dig[i]); digitalWrite(latchPin, HIGH); //Muestra delay(500); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones bit y byte</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/functions/advanced-io/shiftout/ Guia de referencia] * [https://www.prometec.net/funciones1/ Funciones de Arduino] - Prometec * [https://www.youtube.com/watch?v=mV-JAVocaLs Registro de desplazamiento 74595] - Editronikx * [https://arduino.perut.org/e_35.htm Shift register] Apuntes de Arduino [[Category:Funciones bit y byte]] 38mirlpshdkb76p926e150stlub5ltu 0 37 4473 4472 2019-06-24T22:38:30Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == Calcula el seno de un ángulo (en radianes). El resultado está comprendido entre -1 y 1. {{Nota|El angulo en radianes se expresa en 2*PI osea [[PI|TWO_PI]]}} == Sintaxis == <pre> sin(rad); </pre> == Parámetros == ;rad: en ángulo en radianes. [[float]] == Retornos == El seno del ángulo [[float]]. Valores entre -1 y +1. == Advertencias == * El angulo debe estar expresado en radianes entre 0 y [[PI|TWO_PI]]. == Ejemplo 1 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); Serial.println(sin(0), 3); //0.000 Serial.println(sin(HALF_PI/2), 3); //0.707 Serial.println(sin(HALF_PI), 3); //1.000 Serial.println(sin(PI), 3); //0.000 Serial.println(sin(PI+HALF_PI), 3); //-1.000 Serial.println(sin(TWO_PI), 3);} //0.000 void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); } void loop(){ for (float n=0; n<TWO_PI; n+=0.01){ Serial.println(sin(n)); } } </syntaxhighlight> == Vea también == * [[cos()]] * [[tan()]] * [[asin()]] * [[acos()]] * [[atan()]] * [[PI]] == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones trigonometricas]] oafgmz23h6ikoms99zrflne5runzdp9 0 186 5273 5272 2020-03-16T15:10:21Z Kike GL 2 /* Ejemplo 1 */ wikitext text/x-wiki == Descripción == Evalúa el tamaño de memoria reservado para una variable o [[matriz]] en bytes. Acepta cualquier tipo de datos: [[char]], [[byte]], [[int]], [[word]], [[long]], [[double]], [[float]], etc. == Sintexis == <pre> sizeof(variable); sizeof(matriz); </pre> == Parámetros == ;matriz:nombre de la matriz a evaluar, que puede ser tipo: [[char]], [[byte]], [[int]], [[word]], [[long]], [[float]]. == Retorna == Número de bytes ocupados por variable o matriz. [[size_t]] == Advertencias == * '''sizeof()''' al contar en bytes, solo coincide con la cantidad de elementos si son tipo: [[bool]] o [[char]] o [[byte]]. * Si quieres hallar el numero de elementos de una matriz: [[int]], [[long]], [[double]] o [[float]]. Lo más correcto sería: <pre> sizeof(matriz) / sizeof(matriz[0]); sizeof(matriz) / sizeof(tipo); </pre> Para así obtener el tamaño en cantidad de elementos y no en bytes. == Ejemplo 1 == Para obtener la cantidad de elementos solo hay que dividir entre el numero de bytes de cada elemento <syntaxhighlight lang="c++"> int valores[] = {1023, 45056, 77}; byte indice = sizeof(valores); //6 bytes byte indice = sizeof(valores) / sizeof(int); //3 elementos bool A[][4] = {{0,1,0,0}, {0,0,1,0}, {0,1,1,0}}; byte indice = sizeof(A); //12 bytes byte indice = sizeof(A) / sizeof(bool); //12 elementos byte indice = sizeof(A) / (4 * sizeof(bool)); //3 fila + 4 columnas </syntaxhighlight> == Ejemplo 2 == Trabajar con una matriz bidireccional. <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); int A[][4] = {{1024,5000,0,24344}, {11111,3000,12345,670}, {0,10000,1,62000}}; byte A1 = sizeof(A); byte A2 = sizeof(A) / sizeof(int); byte A3 = sizeof(A) / (4 * sizeof(int)); Serial.println(A1); //24 bytes Serial.println(A2); //12 elementos Serial.println(A3); //3 filas + 4 columnas } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 3 == Creamos una matriz de caracteres con cierto valor y luego mostramos carácter a carácter. <syntaxhighlight lang="c++"> const byte matriz[]="Esto es una matriz"; void setup(){ Serial.begin(115200); for (byte i=0; i<sizeof(matriz)-1; i++{ Serial.write(matriz[i]); //Caracter Serial.print(" = "); Serial.println(matriz[i]); //Codigo ASCII delay(100); } } void loop(){ //Nada } </syntaxhighlight> == Vea tambien == * [[tone()]] * [[noTone()]] * [[pulseln()]] * [[pulselnLong()]] * [[shiftIn()]] * [[shiftOut()]] * [[matriz]] == Referencias == * [https://www.arduino.cc/reference/en/language/variables/utilities/sizeof/ sizeof()] - Arduino * [http://manueldelgadocrespo.blogspot.com/p/sizeof.html sizeof()] - Manuel Delgado [[Category:Funciones]] de4l6ag05w3xnclo5qxsatrgyjbz5mk 0 366 4045 4044 2019-05-28T01:12:15Z Kike GL 2 /* Ejemplo 3 */ wikitext text/x-wiki == Descripción == Crea una cadena tipo [[string]] formateada en la variable str, en lugar de imprimir. El tamaño del búfer debe ser lo suficientemente grande como para contener toda la cadena resultante (vea [[snprintf()] para una versión más segura). Un carácter nulo de terminación se agrega automáticamente después del contenido. Después del parámetro de formato, la función espera al menos tantos argumentos adicionales como sea necesario para el formato. == Sintaxis == <pre> sprintf(str, formato, argumentos); </pre> == Parámetros == ;str:Puntero a un buffer donde se almacena la cadena tipo [[string]] resultante. El buffer debe ser lo suficientemente grande como para contener la cadena resultante. ;formato:Cadena que contiene el formato que sigue las mismas especificaciones que el formato en [[printf()]]. Puedes representar [[int]] (%d), [[long]] (%ld) y [String|cadenas] (%s). ;argumentos:Dependiendo de la cadena de formato, la función puede esperar una secuencia de argumentos adicionales, cada uno con un valor que se utilizará para reemplazar un especificador de formato en la cadena de formato (o un puntero a una ubicación de almacenamiento, para n). Debe haber al menos tantos de estos argumentos como la cantidad de valores especificados en los especificadores de formato. {| class="wikitable" |+Especificadores disponibles como formato |- ! Especificador !! Descripción !! Ejemplo |- | %d o %i || [[int]] formato decimal || 392 |- | %0d o %0i || [[int]] formato decimal || 03 |- | %o || [[int]] formato octal || 610 |- | &u || [[unsigned int]] || 7235 |- | %x o %X || [[unsigned int]] formato hexadecimal || 12345 |- | %f o %F || [[float]] formato decimal || 3.1416 |- | %a o %A || [[float]] formato hexadecimal || 0XC.90FEP-2 |- | %e o %E || Notación científica || 3.9263e+2 |- | %c || Carácter || a |- | %s || Cadena de caracteres || Hola |- | %p || Puntero || b80000000 |- | %n || No imprime || |- | %% || simbolo % || % |} == Retorno == * En caso de éxito, se devuelve la cantidad total de caracteres escritos. Este recuento no incluye el carácter nulo adicional adjuntado automáticamente al final de la cadena. * En caso de falla, se devuelve un número negativo. == Comentarios == * La función ignora argumentos adicionales. * Un carácter nulo de terminación se agrega automáticamente después del contenido. * Después del parámetro de formato, la función espera al menos tantos argumentos adicionales como sea necesario para el formato. * No maneja [[float]] pero lo puedes imitar con dos enteros. == Advertencias == * La función sprintf() no hace el trabajo de imprimir, solo prepara una variable para ello. * El tamaño del búfer debe ser lo suficientemente grande como para contener toda la cadena resultante (ver [[snprintf]] para una versión más segura). == Ejemplo 1 == Esto tiene 3 enteros de 2 dígitos con ceros a la izquierda, separados por ":". La lista de parámetros, hora, minuto, segundo, proporciona los números con los que se imprime el sprintf. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); char buffer[50]; byte hora = 13; byte min = 2; byte seg = 18; sprintf(buffer, "%02d:%02d:%02d", hora, min, seg); Serial.print(buffer); //13:02:18 sprintf(buffer, "Son las %d horas %d minutos %d segundos.", hora, min, seg); Serial.println(buffer); //Son las 13 horas 2 minutos 18 segundos. } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); char buffer[50]; int n, a=5, b=3; n = sprintf(buffer, "%d plus %d is %d", a, b, a+b); printf("[%s] is a string %d chars long\n",buffer,n); Serial.print(buffer); } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 3 == <syntaxhighlight lang="c++"> void setup(){ char buffer[30]; char buf1[6]; float mfloat = 23.245; dostrf(mfloat, 5, 2, buf1); sprintf(buffer,"Float %s", buf1); Serial.print(buffer); } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 4 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); char texto[50]; int a=5, b=3; sprintf(texto, "%d mas %d es %d", a, b, a+b); Serial.print(texto); } void loop(){ //Nada. } </syntaxhighlight> == Ejemplo 5 == <syntaxhighlight lang="c++"> #include <RTClib.h> #include <SD.h> RTC_Millis rtc; File Archivo; void setup(){ pinMode(10, OUTPUT); //Se establece como salida el pin correspondiente a SS. //Estado SD if (!SD.begin(10)) { Serial.println("Se ha producido un fallo al iniciar la comunicación"); return; } Serial.println("Se ha iniciado la comunicación correctamente"); char archivo[13]; sprintf(archivo, "%4d%02d%02d.txt", year, month, day); /*** INICIO ESCRITURA ***/ Archivo = SD.open(archivo, FILE_WRITE); if (Archivo) { Archivo.println("Esto es lo que se está escribiendo en el archivo"); Archivo.close(); Serial.println("Todos los datos fueron almacenados"); }else{ Serial.println("El archivo no se abrió correctamente"); } /* FIN ESCRITURA */ /*** INICIO LECTURA ***/ Archivo = SD.open(archivo); if (Archivo) { Serial.println("Información contenida en archivo: "); While (Archivo.available()) { Serial.write(Archivo.read()); } Archivo.close(); }else{ Serial.println("El archivo no se abrió correctamente"); } /* FIN LECTURA */} void loop(){ //Si tengo algún dato para escribir if(tengo){ /*** INICIO ESCRITURA ***/ Archivo = SD.open(archivo, FILE_WRITE); if (Archivo) { Archivo.print(year); Archivo.print("Valor pin 11: "); Archivo.println(digitalRead(11)); Archivo.close(); Serial.println("Dato almacenado"); }else{ Serial.println("El archivo no se abrió correctamente"); } /* FIN ESCRITURA */ } } </syntaxhighlight> == Vea también == <categorytree mode=all>Serial</categorytree> == Referencias == * [http://www.cplusplus.com/reference/cstdio/sprintf/ sprint()] - cplusplus * [https://programarfacil.com/blog/arduino-blog/conversion-de-numeros-a-cadenas-en-arduino/ Convesion de numeros a cadena] - Luis del Valle [[Category:Serial]] jc9goyt07sot5om5pn7lgi2cqgkaiv7 0 170 4291 4290 2019-06-11T23:34:44Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Calcula el cuadrado de un número: el número multiplicado por sí mismo. == Sintaxis == <pre> sq(valor); sq(variable); </pre> == Parametros == ;valor: numero a operar ;variable: nombre de variable a operar == Retorna == El cuadrado del numero. Tipo [[long]]. == Advertencias == * Nada == Ejemplos == <syntaxhighlight lang="c++"> byte n = sq(3); //9 sq(n); //81 </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones matematicas</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/en/language/functions/math/sq/ Guia de referencia] [[Category:Funciones matematicas]] h3ovxsadidl9fpygw1hp28yxuomuyeb 0 171 4289 4206 2019-06-11T23:34:18Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Calcula la raíz cuadrada de un número. retorna un float. == Sintaxis == <pre> sqrt(valor); sqrt(variable); </pre> == Parámetros == ;variable: nombre de la variable a operar. == Retorna == Retorna un numero tipo [[float]]. == Advertencias == Nada. == Ejemplo == <pre> sqrt(9); //3 </pre> == Vea también == <categorytree mode=all>Funciones matematicas</categorytree> == Referencias externas == [[Category:Funciones matematicas]] mtqqz3oy9fm1qyzu5dp6zde3svhvypz 0 201 5197 5186 2020-02-02T04:21:05Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Palabra clave conocida como '''calificadora'''. Se usa antes del tipo de datos de una variable, para modificar la manera en que el compilador y el [[boceto]] deben tratar dicha variable. Se usa para crear variables que solo son visibles dentro de una función. Sin embargo a diferencia de las variables locales que se crean y destruyen cada vez que se invoca una función, las variables '''static''' persisten más allá de la llamada a la función, preservan sus datos entre llamadas a funciones. {{Nota|Las variables declaradas como '''static''' sólo se crean e inicializan la primera vez que una función se llama.}} == Sintaxis == <pre> static [tipo] variable [= valor]; </pre> == Parámetros == ;tipo: tipo de dato. Puede ser [[char]], [[byte]]; [[int]], [[long]], [[float]], etc de forma explicita u incluir un subfijo en '''valor''' {| class="wikitable col2cen" |+Subfijos !Tipo!!Subfijo!!Ejemplo |- |[[int]]||ninguno||123 |- |[[unsigned int]]||U||123U |- |[[long]]||L||123L |- |[[unsigned long]]||UL||123UL |- |[[float]]||F||1.23F |} ;variable:nombre de la variable a declarar. ;valor:valor a almacenar en el rango del tipo de dato. Puede especificar la '''base''' del dato usando un prefijo. {| class="wikitable col2cen" |+Prefijos !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1110011 |} == Retorno == Nada. == Comentarios == * Todas las variables son almacenadas en [[SRAM]] salvo [[const]]. == Advertencias == * Solo son visibles dentro de la función donde fueron creadas. * A diferencia de una [[variable local]] que se destruyen al finalizar la función, las variables '''static''' sobreviven a la función y mantienen su valor en la próxima llamada a dicha función. == Ejemplo == <syntaxhighlight lang="c++"> const byte alto = 20; const char bajo = -20; const byte paso = 5; //Tamaño de paso void setup(){ Serial.begin(115200); } void loop(){ static int posicion; int hoy = camino(paso); Serial.println(hoy); delay(10); } int camino(byte mover){ posicion += random(-mover, mover + 1); if (posicion < bajo){ //Comprueba los límites alto y bajo posicion = alto; //Refleja el número de vuelta en dirección negativa }else if(posicion > alto){ posicion = bajo; //Refleja el número de vuelta en dirección positiva } return posicion; } </syntaxhighlight> == Vea también == * [[variable publica]] * [[variable local]] * [[matriz]] * [[volatile]] * [[const]] * [[include|#include]] * [[define|#define]] * [[Comentarios]] - <nowiki>(//)</nowiki> == Referencias == * [https://www.arduino.cc/reference/en/language/variables/variable-scope--qualifiers/static/ Guia de referencia] [[Category:Variables]] swcj7qlt17cysqu71vj8gfxgmr66q1r 0 139 5232 5231 2020-02-02T18:50:45Z Kike GL 2 /* Ejemplo 7 */ wikitext text/x-wiki == Descripción == En realidad '''string''' o cadena de caracteres no es un tipo de dato y se construye como una [[matriz]] de tipo [[char]] con terminación nula. Las cadenas deben terminar con un carácter nulo (ASCII código 0). Esto permite que funciones como Serial.print() sepan donde terminan las cadenas. De lo contrario, seguirían leyendo los siguientes bits de memoria que ya no pertenece a esa cadena. Esto significa que la cadena tiene que tener espacio para un carácter más que el texto que desea que contenga. == Sintaxis == <pre> char variable[] = "valor"; char variable[] = {'val1', 'val2'...}; char* variable = "valor"; </pre> == Parametros == ;variable:Es el nombre de la matriz. ;valor:Es una sola cadena de caracteres entre comillas dobles. ;valx:Es un carácter entre comillas simples. == Comentarios == * Se puede declarar una matriz de tamaño especifico. Ejemplo char cadena_1[15]; * Declarar y asignar una matriz, sin terminal. Ejemplo char cadena_2[8] = {'a','r','d','u','i''n','o'}; * Declarar y asignar una matriz, con terminal. Ejemplo char cadena_3[8] = {'a','r','d','u','i''n','o','\0'}; * Declarar y asignar una matriz. Ejemplo char cadena_4[] = "arduino"; * Declarar y asignar una matriz, dejando espacio en blanco. Ejemplo char cadena_5[15] = "arduino"; * Declarar y asignar una matriz puntero. Ejemplo char* cadena_6[] = {"uno","dos","tres"}; {{Nota|Las cadenas deben terminan con un carácter nulo (código ASCII 0), para permitir que las funciones (como [[Serial.print()]]) sepan dónde termina la cadena. De lo contrario, continuarían leyendo bytes de memoria posteriores que no son realmente parte de la cadena.}} == Matriz de tamaño dinámico == Al instanciar una matriz se reserva espacio en la memoria para almacenar sus elementos y una vez creado es imposible cambiar su tamaño, entre otras cosas porque puede no haber espacio suficiente a continuación en la memoria. Pero nada nos impide crear un nueva matriz con el tamaño deseado (más grande o más pequeño), copiar el contenido de la matriz original y finalmente eliminar la matriz original. Así es precisamente como trabaja una matriz de tamaño dinámico. Pues eso es exactamente lo que hace la libreria [https://github.com/luisllamasbinaburo/Arduino-List List]. == Advertencia == * Tenga en cuenta, que las matrices de caracteres se conocen como '''string''' con s minúscula y las instancias de la '''clase String''' se denominan cadenas con S mayúscula. * Las constantes de cadena especificadas con "comillas dobles" son tratadas como matrices de [[char]] y no como objetos de la clase [[String]]. * Las variables tipo [[char]] deben ser definidos '''siempre''' usando comillas simples. Ver cadena1, cadena2 y cadena3 en ejemplo 1. * Es posible crear cadenas como '''matriz''' de caracteres usando comillas dobles. Ver cadena4, cadena5 y cadena6 en ejemplo 1. * Una vez definida una matriz no puede cambiar de tamaño. Ver matriz dinamica. == Ejemplo 1== Posibilidades para la declaración de cadenas # Declarar una matriz de caracteres inicializandola. Ver cadena1. # Declarar una matriz de caracteres (con un carácter extra) y el compilador añadirá el carácter nulo requerido. Ver cadena2. # Agregar explicitamente el caracter nulo. Ver cadena3. # Inicializar una constante de cadena entre comillas; el compilador ajustará el tamaño de la matriz para adaptarse a la cadena y un carácter nulo de terminación. Ver cadena4. # Incializar una matriz con un tamaño explícito y una constante de cadena. Ver cadena5. # Inicializar la matriz, dejando espacio extra para una cadena larga. Ver cadena6. # Algunos errores. Ver cadena7 y cadena8. <syntaxhighlight lang="c++"> char cadena1[15]; char cadena2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'}; char cadena3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'}; char cadena4[ ] = "arduino"; char cadena5[8] = "arduino"; char cadena6[15] = "arduino"; char cadena7 = 'Arduino'; //Error, falta [] char cadena8[] = 'Arduino'; //Error, debes usar comilla doble. </syntaxhighlight> == Ejemplo 2 == En el código siguiente, el asterisco después del tipo de datos '''char*''' indica que se trata de una matriz de [[puntero]]. Todos los nombres de matrices son en realidad punteros, así que esto es necesario para hacer una matriz de matrices. Los punteros son una de las partes más esotéricas de C ++ para que los principiantes puedan entender, pero no es necesario entender los punteros en detalle para usarlos de la manera aquí descrita. <syntaxhighlight lang="c++"> char* fraces[] = { "Esta es la cadena 1", "Esta es la cadena 2", "Esta es la cadena 3", "Esta es la cadena 4", "Esta es la cadena 5", "Esta es la cadena 6" }; void setup(){ Serial.begin(115200); for (byte i=0; i<6; i++){ Serial.println(fraces[i]); } } void loop(){ //Nada }</syntaxhighlight> == Ejemplo 3 == Como convertir una matriz [[char]] en [[long]]. <syntaxhighlight lang="c++"> char* texto1 = "-12345"; //Es lo mismo que char texto1[] = "-12345"; char* texto2 = "-12.345"; //Es lo mismo que char texto2[] = "-12.345"; void setup(){ Serial.begin(9600); long valor1 = atol(texto1); Serial.println(valor1); float valor2 = atof(texto2); Serial.println(valor2); } void loop(){ //Nada. } </syntaxhighlight> == Ejemplo 4 == En el siguiente ejemplo usuario pretende usar 4K de [[SRAM]] cuando Arduino [[UNO]] solo tiene 2K. <syntaxhighlight lang="c++"> int var[2000]; //Error </syntaxhighlight> == Ejemplo 5 == Para borrar un string se puede usar. <syntaxhighlight lang="c++"> char nom[] = "Arduino"; nom[0] = '\0'; </syntaxhighlight> == Ejemplo 6 == Para añadir un carácter al final se puede usar. Recuerda que debe haber estacio sufiente en el <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); char nom[] = "Arduino"; byte len = strlen(nom); nom[len++] = 's'; Serial.print(nom); } void loop() { //Nada } </syntaxhighlight> == Ejemplo 7 == No se puede crear una [[matriz]] de matrices. Pero si se puede usar punteros a matrices, asi: <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); byte cero[] = { 0xA6, 0xD4, 0xAC, 0xF8 }; byte uno[] = { 0xE9, 0x48, 0xCC, 0xE3 }; byte dos[] = { 0x46, 0x6F, 0xA5, 0xF8 }; byte tres[] = { 0xC2, 0x9D, 0xFC, 0x33 }; byte* matriz[4] = {cero, uno, dos, tres}; for (byte i=0; i<4; i++){ for (byte j=0; j<4; j++){ Serial.print(matriz[i][j], HEX); Serial.print(", "); } Serial.println(); } } void loop() { //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == * [https://www.luisllamas.es/convertir-texto-a-numero-arduino/ Convertir texto a numero] - Luis Llamas * [http://panamahitek.com/tipos-de-datos-arrays-en-arduino/ Tipos de datos: Arrays] - José Villalaz [[Category:Tipo dato]] tnc4vfud0yjxiyo2b0iau8r335b3yhg 0 400 2902 2901 2019-04-03T21:57:01Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == La función determina la longitud de un [[string]] excluyendo el carácter nulo final. == Sintaxis == <pre> strlen(matriz); </pre> == Parámetros == ;matriz:nombre de la matriz [[char]] o [[string]] a analizar == Retorno == La longitud del [[string]] en [[int]]. == Advertencias == Ninguna == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); char nom[] = "Arduino"; Serial.print(strlen(nom)); //7 } void loop() { //Nada }</syntaxhighlight> == Vea también == * [[string]] * [[atol()]] * [[atof()]] == Referencias == [[Category:Funciones]] 4szrc83dt6k2a9j1hdb6qhshf26lbd4 0 403 5098 4509 2019-11-20T16:43:42Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Convertir una matriz [[char]] o [[string]] a [[unsigned long]] en la base dada. == Sintaxis == <pre> strtoul(matriz, *puntero, base); </pre> == Parametros == ;matriz:Nombre de la matriz tipo [[string]]. ;puntero:esta es la referencia a un objeto de tipo char*, cuyo valor es establecido por la función a continuación del valor numérico. ;base:que debe estar entre 2 y 36 inclusive, o el valor especial 0. == Retorno == Numero tipo [[unsigned long]] o 0 si no lo logra. == Advertencias == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); char texto[] = "12345"; char *ptr; unsigned long a = strtoul(texto, &ptr, 10); //12345 a -= 12300; Serial.println(a); //45 } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); char rec[16], *ptr; char data[] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x02, 0x03, 0x0b }; sprintf(rec, "0x%X%X%X%X%X%X%X%X", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); Serial.print("Matriz Hexadecimal: "); Serial.println(rec); unsigned long a = strtoul(rec, &ptr, 16); Serial.print("El numero en decimal es: "); Serial.println(a); } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> == Referencias == * [https://www.luisllamas.es/convertir-texto-a-numero-arduino/ Convertir texto a numero] - Luis LLamas [[Category:Funciones conversion]] o3jwbsomvq8424yqc1aald8kcg4deul 0 91 5030 5029 2019-09-27T00:18:16Z Kike GL 2 /* Retorna */ wikitext text/x-wiki == Descripción == La suma es una de las cuatro operaciones aritméticas primarias. El operador + (más) opera en dos operandos para producir la suma. == Sintaxis == <pre> variable = valor + variable + expresion; </pre> == Retorna == Suma aritmética o concatena si se trata de cadenas [[String]]. == Advertencias == * Al hacer operaciones aritméticas preste atención a los tipo de dato involucrados. * Debido a que toda variable tiene un límite, una suma que resulte en un valor extremedamente alto puede tener un resultado sin sentido (por desbordamiento). Por ejemplo: que una suma de dos enteros positivos resulte en un valor negativo (si la variable es con signo), o que sea menor que el primer operando (si la variable es sin signo). == Ejemplo 1 == <syntaxhighlight lang="c++"> byte x = 10; byte y = 5; x = x + 30; //40 x++; //41 (Incrementa x en uno) x += y; //46 (Incrementa x en y) </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> String frase = "Apuntes"; frase = frase + " de Arduino"; frase = frase + analogRead(A0); frase = frase + millis(); </syntaxhighlight> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias == * [https://www.arduino.cc/reference/en/language/structure/arithmetic-operators/addition/ Guia de referencia de Arduino] * [https://aprendiendoarduino.wordpress.com/2018/04/08/operadores-5/ Operadores] - Enrique Crespo [[Category:Operador aritmetico]] 4gj84m4236nikpkaknqko4wovcl7ew8 0 213 5014 5005 2019-09-26T23:58:39Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Suma un valor y lo guarda en la misma variable. {{Nota|Es lo mismo que variable <nowiki>=</nowiki> variable + valor.}} == Sintaxis == <pre> variable += valor; variable = variable + valor; </pre> == Parámetros == ;variable: Nombre de la variable a operar. Puede ser de cualquier tipo: [[char]], [[byte]], [[int]], [[long]], [[float]]. ;valor: Valor del mismo tipo que variable. == Retorno == Retorna la variable incrementada en valor. == Comentario == * En caso de que la variable sea de tipo [[String]] lo que se hace es concatenar como texto sin importar que sea un numero. Ver ejemplo 2 * Cual es la diferencia entre poner el operador delante o atrás de nombre de la variable ? == Advertencias == * Tenga cuidado con no provocar desborde u obtendrá resultados inesperados. * Tenga en cuanta la sutil diferencia entre += y =+ == Ejemplo 1 == En el caso de datos o variables numéricas se efectúa la '''suma'' y el resultado se guarda en misma variable. <syntaxhighlight lang="c++"> byte n = 5; n += 3; //8 n += 3; //11 </syntaxhighlight> == Ejemplo 2 == En este caso no suma sino que concatena gracias al tipo de variable seleccionado. <syntaxhighlight lang="c++"> String frase = "Apuntes"; frase += " de Arduino "; //Apuntes de Arduino int n = 2018; frase += n; //Apuntes de Arduino 2018 </syntaxhighlight> == Ejemplo 3 == En este ejemplo nos hemos atrevido a usar el incremento sobre una variable tipo [[char]]. Se muestra A, C, E, G, I, K. <syntaxhighlight lang="c++"> void setup(){ Serial.begin(9600); char x = 'A'; Serial.println(x); for (byte n=0; n<5; n++){ x += 2; Serial.println(x); } } void loop(){ } </syntaxhighlight> == Vea también == <categorytree mode=all>Operador aritmetico</categorytree> <categorytree mode=all>Operador aritmetico compuesto</categorytree> == Referencias == [[Category:Operador aritmetico compuesto]] oggnwz70gu3p2du1rnf6ciyzkj5u4vv 0 59 4462 4461 2019-06-24T18:44:26Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripción == Es un condicional múltiple permitiendo evaluar una sola variable y que se ejecute uno o mas trozos de código, comparando la variable con cada uno de los valores especificados en las instrucciones '''case'''. Cuando se encuentra una sentencia case cuyo valor coincide con el de la variable, el código bajo esa declaración '''case''' se ejecuta. {{Tip|También llamado condicional múltiple.}} La palabra reservada [[break]] interrumpe la sentencia '''switch''', y se usa normalmente al final de cada declaración case. Sin una declaración [[break]], la sentencia '''switch''' continuará la ejecución de las siguientes expresiones hasta que se alcanza una interrupción o hasta el final de la sentencia '''switch'''. La palabra reservada '''default''' se usa para ejecutar código cuando el valor ingresado no coincide con ninguno de los '''case'''. Si esto último llega a suceder pero no hay sección '''default''', la sentencia '''switch''' simplemente se ignorará y flujo de código seguirá como si no estuviera ahí. == Sintaxis == <pre> switch (var) { case label1: // instrucciones break; case label2: // instrucciones break; default: // instrucciones [break;] } </pre> == Parámetros == ;var:Variable a evaluar ;labeln:Valor posible de la variable ;default:Es el grupo de instrucciones a ejecutar solo si '''ninguna''' label se alcanzo. == Comentarios== * Puede poner tantos '''case''' como quieras pero siempre se evaluara la misma variable. == Advertencias == No debes olvidar el [[break]] o todas las sentencias serán ejecutas. Puedes olvidar [[break]] solo en la ultima condición. == Ejemplo 1 == En este ejemplo evaluamos la variable '''var''' que obtuvo un dato de un pin analógico. <syntaxhighlight lang="c++"> int var = analogRead(A0); switch (var){ case 1: //hace algo cuando var es igual a 1 break case 2: //hace algo cuando var es igual a 2 break; default: //Opcional //si nada coincide, hace lo predeterminado } </syntaxhighlight> == Ejemplo 2 == En este ejemplo evaluamos la variable '''var''' que obtuvo un dato de un pin analógico. <syntaxhighlight lang="c++"> int var = analogRead(A0); switch (var){ case 1: case 2: case 3: //hace algo cuando var es igual a 1, 2 o 3. break case 4: case 5: case 6: //hace algo cuando var es igual a 4, 5 o 6. break; default: //Opcional //si nada coincide, hace lo predeterminado } </syntaxhighlight> Al no poner [[break]] luego de algunos case se logra que cualquiera de esos valores ejecute el mismo codigo. == Ejemplo 3 == En este ejemplo ponemos un LED RGB (rojo, verde y azul) en los pines digitales 2, 3 y 4. Luego desde el teclado si pulsamos R se prende el LED rojo y lo volvemos a pulsar se apaga. Similar con verde y azul. <syntaxhighlight lang="c++"> void setup() { Serial.begin(9600); pinMode(2, OUTPUT); //Rojo pinMode(3, OUTPUT); //Verde pinMode(4, OUTPUT); //AZUL } void loop() { //Esperamos una tecla if Serial.available()) { char tecla = Serial.read(); switch (tecla){ case 'R': digitalWrite(2, !digitalRead(2)); break; case 'G': digitalWrite(3, !digitalRead(3)); break; case 'B': digitalWrite(4, !digitalRead(4)); break; } } } </syntaxhighlight> == Vea también == <categorytree mode=all>Estructura control</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/en/language/structure/control-structure/switchcase/ Guia de referencia de Arduino] * [http://manueldelgadocrespo.blogspot.com/p/instruccion-swi.html switch] - Manuel Delgado * [http://www.arduino.utfsm.cl/referencia/switch-case/ switch case] - UTFSM * [http://diwo.bq.com/maquinas-de-estado-switch-case/ Maquina de estado] - Diwo [[Category:Estructura control]] i37efsy93mj6pzzaqaab4mztygub935 0 39 4476 4475 2019-06-24T22:44:10Z Kike GL 2 /* Advertencias */ wikitext text/x-wiki == Descripción == Calcula la tangente de un ángulo (en radianes). El resultado está comprendido entre negativo infinito e infinito. == Sintaxis == <pre> tan(rad); </pre> == Parámetros == ;rad: el ángulo en radianes [[float]]. == Retornos == La tangente del ángulo [[float]]. == Advertencias == * El angulo debe estar expresado en radianes. Valores entre 0 y [[PI|TWO_PI]]. == Ejemplo 1 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); Serial.println(tan(0), 3); //0.000 Serial.println(tan(HALF_PI/2), 3); //1.000 Serial.println(tan(HALF_PI), 3); //-22877332.000 Serial.println(tan(PI), 3); //0.000 Serial.println(tan(PI+HALF_PI), 3); //-83858280.000 Serial.println(tan(TWO_PI), 3);} //0.000 void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> void setup(){ Serial.begin(115200); } void loop(){ for (float n=0; n<TWO_PI; n += 0.01){ Serial.println(tan(n)); } } </syntaxhighlight> == Vea también == * [[sin()]] * [[cos()]] * [[asin()]] * [[acos()]] * [[atan()]] * [[PI]] == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones trigonometricas]] 0y3f5wrskts90uj6gqhu0b77z3x8q3y 0 396 3036 3035 2019-04-27T21:11:13Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripcion == Es una funcion para gestionar los serviciod del temporizador. Esta funcion sirve para indicar si la hora se ha establecido y si se ha sincronizado recientemente. == Sintaxis == <pre> timeStatus() </pre> == Parámetros == Ninguno == Retorno == ;timeNotSet:la hora nunca se ha establecido, el reloj comenzó el 1-ENE-1970. Los valores de fecha y hora no son válidos. ;timeNeedsSync:la hora se había establecido pero un intento de sincronización no tuvo éxito. Valores validos pero pueden estar alterados. ;timeSet:La hora esta establecida y sincroniza. == Comentarios == == Advertencias == La funcion '''timeStatus()''' solo esta disponible luego de añadir la libreria [https://github.com/PaulStoffregen/Time TimeLib.h] al [[boceto]]. == Ejemplo 1 == == Vea también == * [[Fecha y hora]] * [[time_t]] - TimeLib.h * [[tmElements_t]] - TimeLib.h * [[setTime()]] - TimeLib.h * [[adjustTime()]] - TimeLib.h * [[makeTime()]] * [[breakTime()]] == Referencia == [[Category:Libreria Time]] 5phw5pa6h24jkgo7pgrut7ynqs043bn 0 360 3467 3208 2019-05-06T00:03:33Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripcion == '''time_t''' es un tipo [[unsigned long]] de 4 byte (32 bits) usado para almacenar los segundos transcurridos desde el 1-ENE-1970 o también llamada [https://www.unixtimestamp.com Unix Time Stamp]. == Sintaxis == <pre> time_t variable [= valor]; </pre> == Parámetros == ;variable: Nombre de la variable que definiras. ;valor: Numero del tipo TimeStamp de UNIX. Numero tipo [[unsigned long]]. == Funciones == {|class="wikitable" |+Funciones disponibles para time_t !Función!!Descripción!!Ejemplo |- |[[now()]]||Almacena la hora actual en tiempo UNIX||time_t t = now(); |- |year()||Muestra el año||year(); |- |month()||Muestra el mes (1~12)||month(); |- |monthStr()||Nombre del mes (January, February, March, April, May, June, July...)||monthStr(month()); |- |monthShortStr()||Nombre corto del mes (Jan, Feb, Mar, Dic) ||monthShortStr(month()); |- |day()||Muetsra el dia (1~31)||day(); |- |weekday()||Muestra dia de la semana (1=domingo) (1~7)||weekday(); |- |dayStr()||Nombre del dia (Sunday, Monday, Tuesday, Wenesday, Thursday, Friday, Saturday)||dayStr(weekday()); |- |dayShortStr()||Nombre corto del dia (Sun, Mon, Tue, Wen, Thu, Fri, Sat)||dayShortStr(weekday()); |- |hour()||Muestra las horas (0~23)||hour(); |- |minute()||Muestra los minutos (0~59)||minute(); |- |second()||Muestra los segundos (0~59)||second(); |- |[[millis()]]||Muestra los milisegundos (0~999)||millis(); |- |hourFormat12()||Formatea a 12 horas|| |- |isAM()||Devuelve verdadero por la mañana||isAM() |- |isPM()||Devuelve verdadero por la tarde||isPM(); |- |[[setTime()]]||Establece fecha-hora. Puede ser en segundos o hr,min,sec,dia,mes,año.||setTime(0,0,0,14,7,2018); |- |[[adjustTime()]]||Ajusta la fecha-hora del sistema agregando un valor||adjustTime(3600); |- |[[setSyncProvider()]]||Establecer proveedor de hora externa|| |- |[[setSyncInterval()]]||Establecer el número de segundos entre re-sincronizaciones|| |- |[[timeStatus()]]||Indica si el tiempo se sincronizado recientemente. Devuelve: timeNotSet/timeNeedSync/timeSet|| |} == Comentarios == * La libreria [https://github.com/PaulStoffregen/Time TimeLib.h] agrega la funcionalidad de reloj a Arduino sin hardware externo. Permite que un [[boceto]] obtenga la hora y la fecha como: segundo, minuto, hora, día, mes y año. * También proporciona tiempo '''time_t''' estándar, por lo que los tiempos transcurridos se pueden calcular fácilmente y los valores de tiempo se pueden compartir en diferentes plataformas. == Advertencias == * Tenga en cuenta que NO se requiere un parámetro para las funciones basicas. Sin embargo como el reloj sigue funcionando la demora en mostrar la hora no sera la misma si capturamos el tiempo en una variable del tipo time_t y la introducimos en las funciones. * Un caso especial son las funciones de texto que requeriran incluir un valor o función para determinar su valor: dayStr(week(t)), dayShortStr(week(t)), monthStr(month()) y monthShortStr(month()). == Ejemplo 1 == En este ejemplo incluimos la fecha hora 2018-7-14 10:0:0 y mostramos su avance cada 1350 milisegundos. <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(9600); setTime(10,0,0,14,7,2018); //h,min,seg,dia,mes,año } void loop(){ time_t t=now(); Serial.print(hour(t)); Serial.print(":"); Serial.print(minute(t)); Serial.print(":"); Serial.println(second(t)); delay(1350); } </syntaxhighlight> == Ejemplo 2 == En este ejemplo podemos enviar la fecha-hora por consola serie. Para convertir Unix Time te recomiendo [https://www.unixtimestamp.com/ usar esto]. Ejemplo: T1552204800 = 2019-MAR-10 8:00:00 <syntaxhighlight lang="c++"> #include <TimeLib.h> #define TIME_HEADER "T" //Encabezado de mensaje de sincronizacion void setup() { Serial.begin(9600); while (!Serial); //Solo se requiere para Leonardo pinMode(13, OUTPUT); Serial.println("Esperando mensaje de sincronizacion"); } void loop(){ if (Serial.available()) { sincro(); } if (timeStatus() == timeSet) { pantalla(); //Muestra fecha hora digitalWrite(13, HIGH); //Sincronizado }else{ digitalWrite(13, LOW); //Requiere sincronizar } delay(1000); } void sincro() { if (Serial.find(TIME_HEADER)) { unsigned long pctime = Serial.parseInt(); if (pctime >= 1357041600) { //Verifica valides de fecha-hora (mayor a 1-ENE-2013) setTime(pctime); //Sincroniza reloj Arduino con fecha-hora recivida por puerto serie } } } void pantalla(){ Serial.print(year()); Serial.print('-'); Serial.print(month()); Serial.print('-'); Serial.print(day()); Serial.print(' '); Serial.print(hour()); printDigito(minute()); printDigito(second()); Serial.println(); } void printDigito(int dig){ Serial.print(':'); if (dig < 10){ Serial.print('0'); } Serial.print(dig); } </syntaxhighlight> == Ejemplo 3 == Con este ejemplo Arduino espera que se envíe desde el monitor un tiempo UNIX del formato T1531526400 (2018-7-14 0:0:0). <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(9600); pinMode(13, OUTPUT); Serial.println("Esperando tiempo UNIX por puerto serie"); } void loop(){ if (Serial.available()) { sincroniza(); } if (timeStatus()!= timeNotSet) { reloj(); } if (timeStatus() == timeSet) { digitalWrite(13, HIGH); //Sincronizado }else{ digitalWrite(13, LOW); //Falta sincronizar } delay(1000); } void reloj(){ Serial.print(year()); Serial.print("-"); if (month()<10){ Serial.print('0'); } Serial.print(month()); Serial.print("-"); if (day()<10){ Serial.print('0'); } Serial.print(day()); Serial.print(" "); if (hour()<10){ Serial.print('0'); } Serial.print(hour()); Serial.print(":"); if (minute() < 10){ Serial.print('0'); } Serial.print(minute()); Serial.print(":"); if (second() < 10){ Serial.print('0'); } Serial.println(second()); } void sincroniza() { const unsigned long DEFAULT_TIME = 1514764800; //1-ENE-2018 if (Serial.find("T")) { unsigned long pc = Serial.parseInt(); //Controla valides mayor a 1-ENE-2018 if (pc >= DEFAULT_TIME) { setTime(pc); //Ajusta la fecha-hora } } } </syntaxhighlight> == Ejemplo 4 == Mostramos las cadenas de dia y mes. Recuerde que no es opcional el parametro. <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(9600); for (byte n=1; n<=7; n++){ Serial.print(dayStr(n)); Serial.print(" - "); Serial.println(dayShortStr(n)); } Serial.println("-------"); for (byte n=1; n<=12; n++){ Serial.print(monthStr(n)); Serial.print(" - "); Serial.println(monthShortStr(n)); } } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria Time</categorytree> == Referencias == * [https://playground.arduino.cc/Code/Time Guia de referencia Arduino] * [https://github.com/PaulStoffregen/Time TimeLib.h] - Paul Stoffregen * [https://github.com/adafruit/RTClib RTClib.h] - Adafruit [[Category:Libreria Time]] 2r5bq9yz9lnrhr1tpmg8279dcqjidk8 0 394 3469 3029 2019-05-06T00:04:07Z Kike GL 2 /* Vea también */ wikitext text/x-wiki '''tmElements_t''' es una matriz de seis (6) elementos que proporciona la libreria TimeLib.h y que permite manipular de manera facil (sin tener que usar el Tiempo Unix) todos los elementos necesarios para definir una fecha-hora. == Sintaxis == <pre> tmElements_t variable; </pre> == Parámetros == ;variable:Nombre de la variable que definiras. == Métodos == {| class="wikitable" |+Metodos disponibles para tmElementos_t |- ! Metodo !! Descripcion |- | .Second || Segundo (0~59) |- | .Minute || Minuto (0~59) |- | .Hour || Hora (0~23) |- | .Day || Dia (1~31) |- | .Month || Mes (1~12) |- | .Year || Año (0~99) resta de 1970. |} == Comentarios == Para representar el año 2019 debes poner 49 (2019-1970) y no olvidar sumar 1920 nuevamente al resultado. == Advertencias == == Ejemplo 1 == En este ejemplo usamos la función [[makeTime()]] para crear el Tiempo Unix de una fecha-hora. Ejemplo 2019-3-21 8:00:00 <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(115200); tmElements_t tx; tx.Second = 0; tx.Minute = 0; tx.Hour = 8; tx.Day = 21; tx.Month = 3; tx.Year = 49; //2019-1970 time_t tiempo = makeTime(tx); Serial.println(tiempo); //1553155200 } void loop(){ //Nada } </syntaxhighlight> == Ejemplo 2 == En este ejemplo usamos la función [[breakTime()]] para descomponer el Tiempo Unix de una fecha-hora. <syntaxhighlight lang="c++"> #include <TimeLib.h> void setup(){ Serial.begin(115200); time_t tiempo = 1553155200; tmElements_t tm; breakTime(tiempo, tm); Serial.print(tm.Year + 1970); Serial.print("-"); Serial.print(tm.Month); Serial.print("-"); Serial.print(tm.Day); Serial.print(" "); Serial.print(tm.Hour); Serial.print(":"); Serial.print(tm.Minute); Serial.print(":"); Serial.print(tm.Second); } void loop(){ //Nada } </syntaxhighlight> == Vea también == <categorytree mode=all>Libreria Time</categorytree> == Referencias == [[Category:Libreria Time]] gvrrrbatnzjqi0dx36hkns19cso5ru7 0 46 4282 4238 2019-06-11T23:29:05Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Genera en un pin una onda cuadrada de la frecuencia especificada (y ciclo de trabajo del 50%). Se puede especificar una duración, de lo contrario la onda continúa hasta una llamada a noTone(). El pin puede ser conectado a un zumbador piezoeléctrico o a un altavoz para reproducir tonos. Sólo un tono puede ser generado a la vez. Si un tono ya se está reproduciendo en un pin diferente, la llamada a tono() no tendrá ningún efecto. Si el tono se está reproduciendo en el mismo pin, la llamada ajustará su frecuencia. {| class="wikitable col2cen col3cen" |+ |- ! Placa !! Frecuencia Mín. (Hz) !! Frecuencia Máx (Hz) |- | [[UNO]], [[MEGA]], [[Leonardo]] y otras placas AVR || 31 || 65535 |- | [[ZERO]] || 41 || 275000 |- | [[DUE]] y Gemma ||colspan=2|No implementado |} Para detalles técnicos ver las notas [https://code.google.com/p/rogue-code/wiki/ToneLibraryDocumentation#Ugly_Details Brett Hagman's]. {{Nota|Si desea reproducir tonos diferentes en varios pines, es necesario llamar [[noTone()]] en un pin antes de llamar a tone() en el siguiente pin.}} == Sintaxis == <pre> tone(pin, frecuencia); tone(pin, frecuencia, duracion); </pre> == Parámetros == ;pin: el pin en el que se quiere generar el tono ;frecuencia: la frecuencia del tono en hertz - [[unsigned int]] ;duracion: la duración del tono en milisegundos (opcional) - [[unsigned long]] == Retornos == Nada. == Advertencias == * El uso de la función '''tone()''' interferirá con la salida PWM en los pines 3 y 11 (en placas distintas de la [[MEGA]]). == Ejemplo 1 == <syntaxhighlight lang="c++"> int melodia[] = {262,196,196,220,196,0,247,262}; int duracion[] = {4,8,8,4,4,4,4,4}; void setup() { for (byte n=0; n<8; n++) { int tiempo = 1000 / duracion[n]; tone(8, melodia[n], tiempo); int pausa = tiempo * 1.30; delay(pausa); noTone(8); } } void loop() { //Nada } </syntaxhighlight> == Ejemplo 2 == Escriba un boceto para leer la entrada analógica y asigne el resultado a un rango de 100 a 1000. Almacene el resultado en una variable local llamada frecuencia. Esta será la frecuencia que toque en el altavoz. Luego use el comando de '''tono()''' para configurar la frecuencia del altavoz en el pin digital 8 durante 10 ms. <syntaxhighlight lang="c++"> void setup() { //Nada } void loop() { int valor = analogRead(A0); valor = map(valor, 200, 900, 100, 1000); tone(8, frec, 10); } </syntaxhighlight> == Vea también == <categorytree mode=all>Funciones tiempo</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/tone/ Guia de referencia de Arduino] * [http://itp.nyu.edu/physcomp/labs/labs-arduino-digital-and-analog/tone-output-using-an-arduino/ Tone output] - ITP Informatica Fisica [[Category:Funciones tiempo]] c1ntbs0g2yuz08vslhc274sd35ygmil 0 135 4648 4647 2019-07-04T16:52:46Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Son palabras reservadas (incluso del lenguaje de programación en el que se basa Arduino: C++) que sirven como los posibles valores para crear variables del tipo [[bool]]. A diferencia de otros lenguajes, es válido utilizarlos incluso para la asignación de variables número entero; ya que equivalen (respectivamente) a 1 y 0. '''true''' (verdadero) comunmente se define como 1, lo cual es correcto, pero '''true''' tiene una definicion mas amplia. Cualquier entero que no es cero es '''true'', en el sentido Booleano. Asi que -1, 2 y -200 son todos definidos como '''true''', tambien, en un sentido Booleano. == Sintaxis == <pre> true false </pre> == Advertencias == * Nota que true y false se deben escribir en minusculas. * Son sinónimos de '''false''' un 0 o la palabra reservada [[HIGH / LOW|LOW]]. * Son sinónimos de '''true''' cualquier numero distinto de 0 y la palabra reservada [[HIGH / LOW|HIGH]]. == Ejemplos == <syntaxhighlight lang="c++"> bool estado = true; bool residuo = numero%5; bool led = LOW; </syntaxhighlight> == Ejemplo 1 == Debido a que [[Print]] ("padre" de [[Stream]], y por ende de clases como [[Serial]]) no implementa una manera específica de lidiar con [[bool]], ni siquiera en el monitor serial aparecería directamente "true" o "false": <syntaxhighlight lang="c++"> bool b = false; Serial.println(b); // Sólo aparecerá "0" b = true; Serial.println(b); // Sólo aparecerá "1" </syntaxhighlight> == Ejemplo 2 == Debido a la naturaleza del tipo de dato [[bool]] se puede negar. <syntaxhighlight lang="c++"> bool x = false; Serial.println(x); //Sólo aparecerá "0" Serial.println(!x); //Sólo aparecerá "1" </syntaxhighlight> == Ejemplo 3 == Nota que en el [[if... else]] no es necesario comparar. <syntaxhighlight lang="c++"> void setup(){ pinMode(LED_BUILTIN, OUTPUT); } void loop(){ if (digitalRead(LED_BUILTIN)){ digitalWrite(LED_BUILTIN, !digitalRead(13)); delay(500); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Palabras reservadas</categorytree> == Referencias externas == * [http://manueldelgadocrespo.blogspot.com/p/false.html false] - Manuel Delgado * [http://manueldelgadocrespo.blogspot.com/p/true.html true] - Manuel Delgado [[Category:Palabras reservadas]] rgszjj4pdlck5qodxjgl43k6bt6k7ol 0 66 4841 4840 2019-07-25T00:50:32Z Kike GL 2 /* Ejemplo */ wikitext text/x-wiki == Descripción == Es el formato numérico de 2 bytes (16 bits), son enteros comprendidos en el rango de 0 a 65,535 (2^16-1). {{Tip|Alternativamente puede verse declarado como tipo [[word]] o '''uint16_t''', sin embargo funciona exactamente igual.}} {{Nota|La diferencia entre enteros sin signo y enteros con signo o [[int]], radica en la forma en que se trata el bit más alto, a veces llamado bit de "signo". En el tipo entero con signo, si el bit más alto es '''1''', el número se interpreta como que es un número negativo y los otros 15 bits se interpretan como complemento matemático a 2.}} == Sintaxis == <pre> unsignet int variable [= valor]; uint16_t variable [= valor]; //En Arduino UNO uint32_t variable [= valor]; //En Arduino DUE size_t variable [= valor]; word variable [= valor]; variable = valorU; </pre> == Parametros == ;variable: nombre de la variable a definir. ;valor: numero entre 0 y 4,294'967,295. Parámetro opcional. ;valorU: forzar tipo con subfijo '''U'''. Puedes omitir '''unsigned int''' antes del nombre de la variable. {| class="wikitable col2cen" |+Posibles formateadores !Base!!Subfijo!!Ejemplo |- |[[unsigned int]]||U||n = 123U |- |[[long]]||L||n = 123L |- |[[unsigned long]]||UL||n = 123UL |- |[[float]]||F||n =12.3F |} {| class="wikitable col2cen" |+Posibles formateadores !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1110011 |} == Comentarios == * Si sumas 1 al valor maximo que de 4,294,967,295 pasa a 0. * Si restas 1 al valor minimo que de 0 pasa a 4,294,967,295. == Advertencias == * En Arduino [[UNO]] y otras placas basadas en el ATmega, los '''unsigned int''' almacenan un numero de 2 bytes (16 bit), con un rango de entre 0 y 32,065 (2^16 - 1). Alternativamente puede verse declarado como tipo '''uint16_t''' o [[word]]. * En Arduino [[DUE]] y [[Zero]], los '''unsigned int''' almacenan un numero de 4 bytes (32 bit), con un rango de 0 a 4,294,967,295 (2^32 - 1). Alternativamente puede verse declarado como tipo '''uint32_t'''. == Ejemplo == <syntaxhighlight lang="c++"> unsigned int x = 12345; x = 12345U; //Con "U" forzamos unsigned int </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Tipo dato]] tg48klfzokl2x9gpgezx1c77c78juer 0 67 3680 3679 2019-05-06T18:40:56Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Es como el tipo de dato [[long]] para almacenar 4 byte (32 bits), pero sin signo es decir no almacena números negativos, teniendo un rango desde 0 a 4,294,967,295 (2^32-1). Alternativamente puede verse declarado como tipo '''uint32_t''', sin embargo funciona exactamente igual. {{Nota|Tenga cuidado al hacer operaciones con numeros enteros ya que si no lo especificas explisitamente, Arduino asume que quieres trabajar con [[int]]. Ver Ejemplo 1.}} == Sintaxis == <pre> unsigned long variable [= valor]; uit32_t variable [= valor]; variable = valorUL; </pre> == Parámetros == ;variable: El nombre de variable a definir. ;valor: Valor que asignamos a la variable en el rango entre 0~4,294,967,295. Parámetro opcional. ;valorUL: Forzar con subfijo '''UL'''. Puedes omitir la palabra '''unsigned long''' antes del nombre de la variable. ;uit32_t: sinonimo de '''unsigned long'''. {| class="wikitable col2cen" |+Posibles formateadores !Base!!Subfijo!!Ejemplo |- |[[unsigned int]]||U||n = 123U |- |[[long]]||L||n = 123L |- |[[unsigned long]]||UL||n = 123UL |- |[[float]]||F||n =12.3F |} {| class="wikitable col2cen" |+Posibles formateadores !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1110011 |} == Advertencias == * Si sumas 1 al valor maximo que de 4,294,967,295 pasa a 0. * Si restas 1 al valor minimo que de 0 pasa a 4,294,967,295. == Ejemplo 1 == Los números 60 y 24 son interpretados como [[int]] por Arduino que soporta maximo de 32,767 de modo que 86,400 no entra. <syntaxhighlight lang="c++"> unsigned long segundos = 60 * 60 * 24; //Error unsigned long segundos = 60UL * 60 * 24; //Ok </syntaxhighlight> == Ejemplo 2 == Hacer parpadear el LED a bordo sin usar [[delay()]]. <syntaxhighlight lang="c++"> unsigned long hora=0; void setup(){ pinMode(LED_BUITIN, OUTPUT); } void loop(){ if (millis() - hora > 500){ hora = millis(); digitalWrite(LED_BUITIN, !digitalRead(LED_BUITIN)); } } </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Tipo dato]] t8jdi7yu5leykjsb66414pko01otwn6 0 458 5223 5222 2020-02-02T18:31:26Z Kike GL 2 /* Referencias externas */ wikitext text/x-wiki == Descripcion == Una variable local es la que es creada dentro de una funcion y solo puede ser usada en dicha funcion, no existindo fuera de este ambito. Normalmente, los valores se tratan como enteros int en base 10 (decimales), pero se puede usar notación especial (formateadores) para ingresar valores de otro tipo (subfijos) y en otras bases (prefijos). == Sintaxis == <pre> void funcion(){ [tipo] variable [= valor]; } </pre> == Parámetros == ;funcion:funcion donde esta disponible esta variable local. ;tipo: define el tipo de variable. [[char]], [[byte]], [[int]], [[long]], [[float]], etc de manera explicita o puede usar un subfijo en '''valor''' {| class="wikitable col2cen" |+Subfijos !Tipo!!Subfijo!!Ejemplo |- |[[int]]||ninguno||123 |- |[[unsigned int]]||U||123U |- |[[long]]||L||123L |- |[[unsigned long]]||UL||123UL |- |[[float]]||F||1.23F |} ;variable:nombre de la variable. ;valor:valor a almacenar en el rango del tipo de dato. Puedes especificar la '''base''' del dato con un prefijo. {| class="wikitable col2cen" |+Prefijos !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1110011 |} == Comentarios == * Todas las variables son almacenadas en [[SRAM]] salvo [[const]]. == Advertencias == La variable local solo existe dentro de la funcion donde fue declarada. == Ejemplo 1 == Conmuta el LED a bordo cuando se pulsa botón. Conectar pulsador entre pin 7 y GND. <syntaxhighlight lang="c++"> volatile bool estado = LOW; void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(7, INPUT_PULLUP); attachInterrupt(0, cambia, CHANGE); } void cambia(){ estado = !estado; } void loop(){ digitalWrite(LED_BUILTIN, estado); } </syntaxhighlight> PD: LOW, LED_BUILTIN, OUTPUT, INPUT_PULLUP y CHANGE son [[Palabras reservadas]]. == Vea también == * [[variable publica]] * [[matriz]] * [[const]] * [[static]] * [[volatile]] * [[extern]] * [[define|#define]] * [[Comentarios]] - (//) * [[Palabras reservadas]] == Referencias externas == * [https://www.prometec.net/intro-programacion/ Introduccion a la programacion] - Prometec [[Category:Variables]] td3w9t6smihw0k8ncaqueprzxbauq4c 0 459 5218 5211 2020-02-02T05:09:59Z Kike GL 2 /* Parámetros */ wikitext text/x-wiki == Descripción == Una variable '''publica''' es la que esta disponible en cualquier parte del [[boceto]]. Normalmente, los valores se tratan como enteros [[int]] en base 10 (decimales), pero se puede usar notación especial (formateadores) para ingresar valores de otro tipo (subfijos) y en otras bases (prefijos). == Sintaxis == <pre> [tipo] variable [= valor]; </pre> == Parámetros == ;tipo: define el tipo de variable. [[char]], [[byte]], [[int]], [[long]], [[float]], etc de forma explicita o usar un subfijo. {| class="wikitable col2cen" |+Subfijos !Tipo!!Subfijo!!Ejemplo |- |[[int]]||ninguno||123 |- |[[unsigned int]]||U||123U |- |[[long]]||L||123L |- |[[unsigned long]]||UL||123UL |- |[[float]]||F||1.23F |} ;variable:nombre de la variable. ;valor:valor a almacenar en el rango del tipo de dato. Puede especificar la '''base''' del dato usando un prefijo. {| class="wikitable col2cen" |+Prefijos !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1110011 |} == Comentarios == * Todas las variables son almacenadas en [[SRAM]] salvo [[const]]. == Advertencias == Para que una variable sea publica debe estar declarada fuera de cualquier funcion. == Ejemplo == Conmuta el LED a bordo cuando se pulsa botón. Conectar pulsador entre pin 7 y GND. <syntaxhighlight lang="c++"> bool estado = LOW; //Variable publica void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(7, INPUT_PULLUP); attachInterrupt(0, cambia, CHANGE); } void cambia(){ estado = !estado; } void loop(){ digitalWrite(LED_BUILTIN, estado); } </syntaxhighlight> PD: LOW, LED_BUILTIN, OUTPUT, INPUT_PULLUP y CHANGE son [[Palabras reservadas]]. == Vea también == * [[variable local]] * [[matriz]] * [[static]] * [[const]] * [[volatile]] * [[extern]] * [[define|#define]] * [[Palabras reservadas]] * [[Comentarios]] - (//) == Referencias externas == [[Category:Variables]] l734gq1mpdxyt9j0vgu8o8ndwg9vtly 0 69 5228 5227 2020-02-02T18:36:58Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == Este tipo no representa dato alguno, sino que es una palabra reservada usada para indicar alguna de las siguientes: * Declarar una función de manera que no se espere ningún dato en su retorno. * Indicar explícitamente que una función no requiere parámetros. * Como tipo de puntero en el parámetro de una función, para indicar que en realidad acepta un puntero de cualquier tipo (aunque para hacer uso de este, primero se debe reinterpretar al tipo que sea necesario). {{Tip|Reservado para la declaración de funciones sin valor de retorno.}} == Sintaxis == <pre> void funcion(){}; void funcion(void){}; void funcion(void* puntero){}; </pre> == Advertencias == Con los '''void*''' hay que tener cuidado; debido a que, si acepta de cualquier tipo y accidentalmente se inserta un puntero a un objeto, este último podría acabar corrompido. == Ejemplo == <syntaxhighlight lang="c++"> void setup(){ //Se ejecuta una sola vez } void loop(){ //Se ejecuta muchas veces } </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> * [[setup()]] * [[loop()]] * [[return]] == Referencias externas== * [https://www.prometec.net/intro-programacion/ Introduccion a la programacion] - Prometec [[Category:Tipo dato]] ds8hpebku93azfjmfi5q05ydhrj7kys 0 202 5202 5172 2020-02-02T04:31:51Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Palabra clave conocida como '''calificadora'''. Se usa antes del tipo de datos de una variable, para modificar la manera en que el compilador y el [[boceto]] deben tratar dicha variable. La declaración de una variable '''volatile''' es una directiva del compilador. El compilador es un software que traduce el código Arduino en el código de máquina, que son las instrucciones reales para el chip ATmel en el Arduino. Específicamente, el compilador carga la variable de [[SRAM]] y no de un registro de almacenamiento, que es una ubicación de memoria temporal donde se almacenan y manipulan las variables del programa. Bajo ciertas condiciones, el valor de una variable almacenada en los registros puede ser inexacto. {{Nota|Una variable debe ser declarada '''volatile''' cada vez que su valor pueda ser cambiado por algo más allá del control de la sección de código en la que aparece, como otro código que se ejecuta simultáneamente.}} En Arduino, el único lugar que es probable que esto ocurra es en secciones de código asociadas a las interrupciones, que llaman a una rutina de servicio de interrupción. == Sintaxis == <pre> volatil [tipo] variable [= valor]; </pre> == Parámetros == ;tipo: define el tipo de variable. [[char]], [[byte]], [[int]], [[long]], [[float]], etc de manera explicita o puede usar un subfijo en valor. {| class="wikitable col2cen" |+Subfijos !Tipo!!Subfijo!!Ejemplo |- |[[int]]||ninguno||123 |- |[[unsigned int]]||U||123U |- |[[long]]||L||123L |- |[[unsigned long]]||UL||123UL |- |[[float]]||F||1.23F |} ;variable:nombre de la variable. ;valor:valor a almacenar en el rango del tipo de dato indicando la '''base''' del dato como prefijo. {| class="wikitable col2cen" |+Prefijos !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1110011 |} == Advertencias == Nada. == Ejemplo 1 == <syntaxhighlight lang="c++"> volatile n = 123 //int volatile n = 123U //unsigned int volatile n = 123L //long volatile n = 123UL //unsigned long volatile n = 1.23F //float volatile byte n = 123; volatile byte n = B1110011; volatile byte n = 0173; volatile byte n = 0x7B; </syntaxhighlight> == Ejemplo 2 == Conmuta el LED a bordo cuando se pulsa botón. Conectar pulsador entre pin 7 y GND. <syntaxhighlight lang="c++"> volatile bool estado = LOW; void setup(){ pinMode(LED_BUILTIN, OUTPUT); pinMode(7, INPUT_PULLUP); attachInterrupt(0, cambia, CHANGE); } void cambia(){ estado = !estado; } void loop(){ digitalWrite(LED_BUILTIN, estado); } </syntaxhighlight> == Vea también == * [[variable publica]] * [[variable local]] * [[matriz]] * [[static]] * [[const]] * [[extern]] * [[define|#define]] * [[Palabras reservadas]] * [[Comentarios]] - <nowiki>(//)</nowiki> == Referencias == * [http://www.cplusplus.com/doc/tutorial/constants/ cplusplus] [[Category:Variables]] c23w3om4lits71zus2c5fur697gvnqv 0 61 5259 4360 2020-02-04T13:21:39Z Kike GL 2 /* Parámetros */ wikitext text/x-wiki == Descripción == Los bucles '''while''' se ejecutan de forma continua, e infinitamente, hasta que la expresión dentro del paréntesis () se convierte en falsa o se llegue a una sentencia [[break]]. Algo debe cambiar la variable de prueba, o el bucle '''while''' nunca se terminará. Este cambio podría ser en el código, tal como que una variable sea incrementada, o una condición externa, tal como la comprobación de un sensor. == Sintaxis == <pre> while (expresion){ //ejecutar } </pre> == Parámetros == ;expresion: una instrucción (boolean) que se evalúa como verdadera o falsa. == Advertencias == Nada. == Ejemplo == <syntaxhighlight lang="c++"> byte var = 0; while (var < 200){ //repite algo 200 veces var++; } </syntaxhighlight> == Vea también == <categorytree mode=all>Estructura control</categorytree> == Referencias externas == * [http://arduino.cc/en/Reference/While Guia de referencia de Arduino] * [https://aprendiendoarduino.wordpress.com/tag/estructuras-de-control/ Estructuras de control] - Enrique Crespo * [http://www.ardumania.es/el-bucle-while/ El bucle while] - Manuel Delgado [[Category:Estructura control]] ezgn944f7xjcggxkid8rcupramgy3ok 0 71 4521 3684 2019-06-25T21:39:17Z Kike GL 2 /* Descripción */ wikitext text/x-wiki == Descripción == '''word''' (palabra) almacena un número entero de 2 bytes (16 bits) sin signo; en otras palabras, comprende el rango de 0 a 65,535 (2^16-1). {{Tip|Alternativamente puede verse declarado como tipo [[unsigned int]] o '''uint16_t''', sin embargo funciona exactamente igual.}} {{Nota|* '''word''' es prácticamente el tipo de dato universal para declarar variables de 2 bytes (16 bits); ya que, independientemente de la arquitectura del uC, siempre será de dicho tamaño.}} == Sintaxis == <pre> word variable [= valor]; uint16_t variable [= valor]; unsigned int variable [= valor]; variable = valorU; </pre> == Parámetros == ;uint16_t:Sinonimo de '''word''' y [[unsigned int]]. ;variable:nombre de la variable. ;Valor:Valor a asignar entre 0 y 65,535. Parámetro opcional. ;valorU: Forzar valor de este tipo de dato. Puedes omitir el tipo. {| class="wikitable col2cen" |+Posibles formateadores !Base!!Prefijo!!Comentario!!Ejemplo |- |DEC||ninguno||Dígitos 0~9||123 |- |HEX||0x||dígitos 0~9 + Caracteres A~F||0x7B |- |OCT||0||digitos 0~7||0173 |- |BIN||B||0 o 1||B1111011 |} == Comentario == Para [[UNO]] '''word''' es lo mismo que [[unsigned int]] y se prefiere este ultimo. == Advertencias == * En Arduino [[UNO]] y otras placas ATmega, '''word''' es equivalente a [[unsigned int]] porque ambos son de 2 bytes (16 bit). * En Arduino [[DUE]] y [[Zero]], '''word''' de 4 bytes (32 bit) por lo que es diferente a [[unsigned int]] que es 2 bytes (16 bits). == Ejemplo == El valor está expresado en hexadecimal, equivale a 32,768 (es justamente la mitad entera más uno de 65,535). <syntaxhighlight lang="c++"> word x = 0x8000; //32768 uint16_t x = 32768; x = 32768U; </syntaxhighlight> == Vea también == <categorytree mode=all>Tipo dato</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Tipo dato]] n59ffawxvakqmmutnwxybaficccysfk 0 181 4309 4230 2019-06-11T23:46:31Z Kike GL 2 /* Vea también */ wikitext text/x-wiki == Descripción == Convierte un valor de cualquier tipo a un dato tipo [[word]] o [[unsigned int]]. == Sintaxis == <pre> word(variable); word(h,l); </pre> == Parámetros == ;variable:Variable a convertir de cualquier tipo. ;h:El byte más significativo (más a la izquierda) de la variable. ;l:El byte menos significativo (más a la derecha) de la variable. == Retorna == Retorna un [[word]] o [[unsigned int]]. == Advertencias == * El tipo [[word]] es prácticamente el tipo de dato universal para declarar variables de 2 bytes (16 bits); ya que, independientemente de la arquitectura del uC, siempre será de dicho tamaño. * En Arduino [[UNO]] los tipod [[word]] y [[unsigned int]] sólo aplica en placas basadas en el ATmega * En Arduino [[DUE]] y [[Zero]], [[unsigned int]] almacena un número sin signo de 4 bytes (32 bit). * No funciona con cadenas [[string]] ni objetos [[String]]. == Ejemplo == <pre> </pre> == Vea también == <categorytree mode=all>Funciones conversion</categorytree> == Referencias externas == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] [[Category:Funciones conversion]] gmyevh2mo2yl6p1eaaf1yi1m1w9wnly 0 209 5298 5290 2020-06-06T21:40:47Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Es un operador boleano '''xor''' <nowiki>^</nowiki> que permite unir dos expresiones lógicamente. {| class="wikitable col3cen" !a!!b!!a <nowiki>^</nowiki> b |- |0||0||0 |- |1||0||1 |- |0||1||1 |- |1||1||0 |} == Sintaxis == <pre> espresion 1 ^ expresion 2 espresion 1 xor expresion 2 </pre> == Retorna == Verdadero o falso. == Advertencias == * No confundir el operador boleano '''xor''' <nowiki>^</nowiki>, con el operador [[xor bit a bit]] <nowiki>|</nowiki>. == Ejemplo == <pre> </pre> == Vea también == <categorytree mode=all>Operador logico</categorytree> <categorytree mode=all>Operador bit a bit</categorytree> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [https://programarfacil.com/blog/programacion/la-logica-en-la-programacion/ La lógica en la programacion] - Luis Del Valle * [https://aprendiendoarduino.wordpress.com/category/operadores/ Operadores] - Aprendiendo Arduino [[Category:Operador logico]] a2ijxdodat14jto9smj9b9ye2ax1frx 0 210 4988 4975 2019-09-26T23:29:04Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == Es un operador '''xor bit a bit''' <nowiki>^</nowiki> (or exclusivo) que establece (pone en 1) un bit sí y solo si el bit de esa posición está establecido (en 1) únicamente en uno de los operandos. {| class="wikitable col3cen" !a!!b!!a <nowiki>^</nowiki> b |- |0||0||0 |- |1||0||1 |- |0||1||1 |- |1||1||0 |} == Sintaxis == <pre> variable1 ^ variable2 </pre> ;variable1: primer operando, es la variable (de cualquier tipo) a modificar. ;variable2: segundo operando, es quien va a relizar las modificaciones pertinentes. == Retorna == El valor resultante, donde cada bit es invertido si así lo dicta el segundo operando. == Advertencias == * No confundir el operador '''xor bit a bit''' <nowiki>^</nowiki>, con el operador boleano [[xor]] <nowiki>x</nowiki>. == Comentario == * Este operador se usa a menudo para invertir cada bites (es decir si cambio de 0 a 1, o de 1 a 0) algunos de los bits en una expresión entera. '''¡Es como un [[not bit a bit]] pero con la posibilidad de ser parcial!''' * En una operación OR si hay un 1 en el bit de máscara, el bit se invierte; si hay un 0, el bit se mantiene igual. == Ejemplo 1 == <syntaxhighlight lang="c++"> byte a = B1100; byte b = B1010; a ^ b; //0110 </syntaxhighlight> == Ejemplo 2 == <syntaxhighlight lang="c++"> byte b = 55; b ^= b; // Así es como en lenguaje máquina se reestablece una variable a cero b = 55; b ^= ~b; // Así es como en lenguaje máquina se reestablece una variable a su máximo valor (-1 si es con signo) </syntaxhighlight> == Ejemplo 3 == Parpadea el LED a bordo. <syntaxhighlight lang="c++"> void setup () { DDRB = DDRB | 32; //Configura el pin digital 13 como OUTPUT, no altera el resto. 32=B00100000; } void loop () { PORTB = PORTB ^ 32; //Invertido estado del bit 5 (pin digital 13), no altera el resto. delay(500); } </syntaxhighlight> == Vea también == * [[not]] <nowiki>(!)</nowiki> * [[and]] <nowiki>(&&)</nowiki> * [[or]] <nowiki>(||)</nowiki> * [[xor]] <nowiki>(^)</nowiki> * [[not bit a bit]] <nowiki>(~)</nowiki> * [[and bit a bit]] <nowiki>(&)</nowiki> * [[or bit a bit]] <nowiki>(|)</nowiki> * [[bitshift right]] <nowiki>(>>)</nowiki> * [[bitshift left]] <nowiki>(<<)</nowiki> <categorytree mode=all>Funciones bit y byte</categorytree> == Referencias == * [https://www.arduino.cc/reference/es/language/functions/time/millis/ Guia de referencia de Arduino] * [http://manueldelgadocrespo.blogspot.com/p/xor-bit-bit.html XOR bit a bit] - Manuel Delgado Crespo * [https://playground.arduino.cc/Code/BitMath/#bitwise_xor Bitwise XOR] - Playground [[Category:Operador bit a bit]] bdi2rri9g22v619epjcgznaoerdey3u 0 381 5024 5016 2019-09-27T00:09:59Z Kike GL 2 /* Referencias */ wikitext text/x-wiki == Descripción == El operador '''xor bit a bit compuesto''' <nowiki>(^=)</nowiki> se usa a menudo para invertir (toggle) determinados bits en una variable. {| class="wikitable col3cen" !a!!b!!a <nowiki>^=</nowiki> b |- |0||0||0 |- |1||0||1 |- |0||1||1 |- |1||1||0 |} {{Nota|A menudo se hace referencia en las guías de programación como "invertido" (TOGLE) de bits.}} == Sintaxis == <pre> variable ^= mascara; variable = variable ^ mascara; </pre> == Parametros == ;variable: Nombre de la variable sobre la cual operar. Puede ser: [[char]], [[byte]], [[int]] o [[long]]. ;mascara: Constante entera puede ser [[char]], [[byte]], [[int]] o [[long]]. == Retorno == * Los bits tratados con 0, mantienen su estado. * Los bits tratados con 1, cambian su estado. == Comentario == Debido a que se trata de bits de un operador de bits - es conveniente usar el formateador binario con constantes. Las cifras siguen siendo el mismo valor en otras representaciones, que simplemente no son tan fáciles de entender. Además, B00000000 se muestra por claridad, pero cero en cualquier formato de número es cero. == Advertencia == Nada. == Ejemplo 1 == Para conmutar los 2 bits menos significativos de una variable, dejando el resto de la variable sin cambios, se use el operador '''xor bit a bit compuesto''' (^=) con la constante B00000011. <syntaxhighlight lang="c++"> byte a = B10101010; a ^= B00000011; //B10101001 </syntaxhighlight> == Vea también == * [[incremento]] <nowiki>(++)</nowiki> * [[decremento]] <nowiki>(--)</nowiki> * [[suma compuesta]] <nowiki>(+=)</nowiki> * [[resta compuesta]] <nowiki>(-=)</nowiki> * [[multiplicacion compuesta]] <nowiki>(*=)</nowiki> * [[division compuesta]] <nowiki>(/=)</nowiki> * [[modulo compuesto]] <nowiki>(%=)</nowiki> * [[or bit a bit compuesto]] <nowiki>(|=)</nowiki> * [[and bit a bit compuesto]] <nowiki>(&=)</nowiki> == Referencias externas == [[Category:Operador bit a bit compuesto]] 0opbyb016mm00pvwmcg77rpm4gd6gdc 1 112 1511 1464 2018-07-04T15:25:27Z Kike GL 2 wikitext text/x-wiki Por si tienen dudas sobre la edición [https://www.mediawiki.org/wiki/Help:Formatting/es consultar aquí], saludos, --[[Usuario:Kike GL|Kike GL]] ([[Usuario discusión:Kike GL|discusión]]) 12:13 18 jun 2018 (EDT) Pretendemos superar con creces la Guia de Referencia de Arduino '''oficial''' por eso: # Cada articulo deberá contener '''como minimo''' la traducción de la Guía en ingles # Luego esta pequeña comunidad deberá mejorar el texto (simple pero claro), poner parametros, retorno, advertencias y comentarios pertinentes. # Es muy importante poner ejemplos desde los mas simples y obvios hasta los mas rebuscados usos del comando. # Hacer referencia a comandos pertinentes o librerías que puedan ayudar. # Poner referencias externas. Esto orienta a quien quiere investigar mas sobre dicho tema. Recuerden '''nunca''' terminaremos este Wiki, siempre hay cosas nuevas o mejoras, --[[Usuario:Kike GL|Kike GL]] ([[Usuario discusión:Kike GL|discusión]]) 14:00 3 jul 2018 (EDT) sbb7z9hva7r1xrwousylrfs9qssxcef 1 108 257 2018-06-17T02:35:34Z Kike GL 2 Página creada con «Hola a todo: Se que la elección de colores quizás no sea la mas afortunada, pero entiendo que lo importante es la legibilidad. Espero sus comentario, saludos --~~~~» wikitext text/x-wiki Hola a todo: Se que la elección de colores quizás no sea la mas afortunada, pero entiendo que lo importante es la legibilidad. Espero sus comentario, saludos --[[Usuario:Kike GL|Kike GL]] ([[Usuario discusión:Kike GL|discusión]]) 22:35 16 jun 2018 (EDT) 75a3bmchuqo5zk1h087axnqjwug3h5m 1 286 1170 2018-06-28T16:11:16Z Kike GL 2 Página creada con «Creo que cada método debería ser tener su propia pagina o esta sera muy grande. --~~~~» wikitext text/x-wiki Creo que cada método debería ser tener su propia pagina o esta sera muy grande. --[[Usuario:Kike GL|Kike GL]] ([[Usuario discusión:Kike GL|discusión]]) 12:11 28 jun 2018 (EDT) 4yjz5owepg3xz3ktwy7h2g2zp2j0yyf 1 220 944 943 2018-06-26T14:31:02Z Kike GL 2 wikitext text/x-wiki Falta mencionar cuando se destruye o libera el espacio reservado para una variable. --[[Usuario:Kike GL|Kike GL]] ([[Usuario discusión:Kike GL|discusión]]) 10:29 26 jun 2018 (EDT) fjdxmcvgeekg3ch9i8nfpn5r7abhe0f 1 164 612 611 2018-06-22T14:48:47Z Kike GL 2 Página blanqueada wikitext text/x-wiki phoiac9h4m842xq45sp7s6u21eteeq1 2 306 1463 1462 2018-07-03T17:51:56Z Kike GL 2 wikitext text/x-wiki {| class="wikitable" |Descripción||Soy de México, Ingeniero Industrial, siempre amo la electrónica y sé ... ¡¡Usar Arduino para aprender nuevas formas de mejorar el mundo !!. Soldador, maquinista, soñador y creador. Bebo tequila pero no café. |- |Vive en||Michoacan - Mexico GMT-5 |- |Website||??? |- |Contactar en||[https://forum.arduino.cc/index.php?topic=542577.0 Foro Arduino en español] |} 77nh1a60u30yxb7y6vek1p78wwnfyzu 2 109 278 276 2018-06-18T15:49:11Z Kike GL 2 wikitext text/x-wiki {| class="wikitable" |Descripción||??? |- |Vive en||Alicante-España (GMT+2) |- |Website||[http://www.jopapa.me/ Cosas Arduino, esp8266 y más] |- |Contactar en||[https://forum.arduino.cc/index.php?topic=542577.0 Foro Arduino en español] |} fx395utboazezegs8ykjiyks41xcqu1 2 64 594 310 2018-06-21T22:50:21Z Kike GL 2 wikitext text/x-wiki {| class="wikitable" |Descripción||Ingeniero electrónico con especialidad en electrónica digital y controles industriales. |- |Vive en||Lima, Perú. GMT-5 |- |Website||[http://arduino.perut.org Apuntes de Arduino] |- |Contactar en||[https://forum.arduino.cc/index.php?topic=542577.0 Foro Arduino en español] |} <categorytree mode="pages">Referencias‎</categorytree> <categorytree mode="pages">Librerias‎</categorytree> <categorytree mode="pages">Ejemplos‎</categorytree> Si necesitas ayuda con la edicion en MediWiki [https://m.mediawiki.org/wiki/Help:Contents/es consulta aqui] a84mwed9d5kg0rg6a8rjq12b4rijcbd 2 107 279 256 2018-06-18T15:51:15Z Kike GL 2 wikitext text/x-wiki {| class="wikitable" |Descripción||??? |- |Vive en||Costa Rica (GMT-6) |- |Website||??? |- |Contactar en||[https://forum.arduino.cc/index.php?topic=542577.0 Foro Arduino en español] |} ohkv9ej5rx3m7dpprzaw4l92ei3950k 2 115 296 2018-06-18T17:07:19Z Kike GL 2 Página creada con «{| class="wikitable" |Descripción||??? |- |Vive en||Palencia, España (GMT+2) |- |Website||??? |- |Contactar en||[https://forum.arduino.cc/index.php?topic=542577.0 Foro Ar...» wikitext text/x-wiki {| class="wikitable" |Descripción||??? |- |Vive en||Palencia, España (GMT+2) |- |Website||??? |- |Contactar en||[https://forum.arduino.cc/index.php?topic=542577.0 Foro Arduino en español] |} amyk099kom8lno68xzsoscnb4oknkvq 2 374 2107 2106 2018-07-18T20:24:56Z Kike GL 2 wikitext text/x-wiki {| class="wikitable" |Descripción||Estudiante de Electrónica y Telecomunicaciones |- |Vive en||Ecuador GSM-6 |- |Website||??? |- |Contactar en||[https://forum.arduino.cc/index.php?topic=542577.0 Foro Arduino en español] |} s9meyz0abjbtfo4wraqsvdebbiktass 2 305 1425 2018-07-02T23:41:41Z Kike GL 2 Página creada con «{| class="wikitable" |Descripción||??? |- |Vive en||??? |- |Website||??? |- |Contactar en||[https://forum.arduino.cc/index.php?topic=542577.0 Foro Arduino en español] |}» wikitext text/x-wiki {| class="wikitable" |Descripción||??? |- |Vive en||??? |- |Website||??? |- |Contactar en||[https://forum.arduino.cc/index.php?topic=542577.0 Foro Arduino en español] |} 5g7dub10f7hw5utz3yq9869g4742sj7 3 110 280 2018-06-18T15:52:45Z Kike GL 2 Página creada con «Bienvenido Jopapa, cual quieres que sea la estructura de la sección Librerías ? saludos, --~~~~» wikitext text/x-wiki Bienvenido Jopapa, cual quieres que sea la estructura de la sección Librerías ? saludos, --[[Usuario:Kike GL|Kike GL]] ([[Usuario discusión:Kike GL|discusión]]) 11:52 18 jun 2018 (EDT) 1xs3uo1camb8awwhahecn26d3uz640u 3 113 284 2018-06-18T16:15:26Z Jopapa 4 Estructura librerias wikitext text/x-wiki Supongo que la estructura será tal como esta en la página en ingles (https://playground.arduino.cc/Main/LibraryList#MotionControl). Dividido por categorias, dada la gran cantidad de librerias. Lo que no se es como se crea esa estructura, si tienes que ser tu y yo ir añadiendo entradas. bn6p0945gywrmmr21ejd5jrqh43jet1 4 12 56 2018-06-13T17:39:59Z Kike GL 1 Página creada con «Arduino es hardware libre. Este es un wiki para ayudar a los novatos en este mundo.» wikitext text/x-wiki Arduino es hardware libre. Este es un wiki para ayudar a los novatos en este mundo. 4frxufasjw92tckw647f5cie47zz4cs 4 85 218 217 2018-06-16T18:40:40Z Kike GL 2 wikitext text/x-wiki Este wiki pretende llenar un vacío generado por la [https://www.arduino.cc/reference/es/ Guía de Referencia Arduino]. Pensamos que un proyecto comunitario como este puede aportar mucho como una verdadera guía, con ejemplos, notas y advertencias que provienen de la experiencia de sus editores. {{Nota|Si te identificas con esta idea y eres al menos '''Full Member''' en el foro de Arduino es Español crear una cuenta en este wiki y luego solicita tu promoción a '''editor''' así podrás contribuir.}} Si ya eres usuario registrado tienes la opción de agregar comentarios en las paginas de discusión para que un editor las considere. Todo este texto es de '''dominio publico'''. Puedes leer tamien: [https://creativecommons.org/publicdomain/zero/1.0/ Creative Commons Zero (dominio público)] Atentamente, El equipo de editores. 56rlpd1te8yb4mp0szku22szg3xd8m1 8 21 824 823 2018-06-25T18:48:32Z Administrador 1 css text/css /* El CSS colocado en esta página afectará a los usuarios que usen la apariencia "Vector" */ body{ text-align: justify; } pre{ background: Thistle; text: Purple; border: 1px solid Purple; Border-Radius: 8px; } /** Estilos para tablas. la idea es, si se quiere que la primera columna de la tabla esté alineada a la derecha, la segunda centrada y la tercera a la izquierda, usar {| class="col1der col2cen col3izq" en vez de repetir "style='text-align:right'", etc, en '''cada''' celda Esto sólo se usa en Medallero. Debería divulgarse para aprovecharlo en más lugares **/ .col1der TD:first-child {text-align:right} .col1izq TD:first-child {text-align:left} .col1cen TD:first-child {text-align:center} .col2der TD:first-child + TD {text-align:right} .col2izq TD:first-child + TD {text-align:left} .col2cen TD:first-child + TD {text-align:center} .col3der TD:first-child + TD + TD {text-align:right} .col3izq TD:first-child + TD + TD {text-align:left} .col3cen TD:first-child + TD + TD {text-align:center} .col4der TD:first-child + TD + TD + TD {text-align:right} .col4izq TD:first-child + TD + TD + TD {text-align:left} .col4cen TD:first-child + TD + TD + TD {text-align:center} .col5der TD:first-child + TD + TD + TD + TD {text-align:right} .col5izq TD:first-child + TD + TD + TD + TD {text-align:left} .col5cen TD:first-child + TD + TD + TD + TD {text-align:center} .col6der TD:first-child + TD + TD + TD + TD + TD {text-align:right} .col6izq TD:first-child + TD + TD + TD + TD + TD {text-align:left} .col6cen TD:first-child + TD + TD + TD + TD + TD {text-align:center} .col7der TD:first-child + TD + TD + TD + TD + TD + TD {text-align:right} .col7izq TD:first-child + TD + TD + TD + TD + TD + TD {text-align:left} .col7cen TD:first-child + TD + TD + TD + TD + TD + TD {text-align:center} .col8der TD:first-child + TD + TD + TD + TD + TD + TD + TD {text-align:right} .col8izq TD:first-child + TD + TD + TD + TD + TD + TD + TD {text-align:left} .col8cen TD:first-child + TD + TD + TD + TD + TD + TD + TD {text-align:center} .col9der TD:first-child + TD + TD + TD + TD + TD + TD + TD + TD {text-align:right} .col9izq TD:first-child + TD + TD + TD + TD + TD + TD + TD + TD {text-align:left} .col9cen TD:first-child + TD + TD + TD + TD + TD + TD + TD + TD {text-align:center} esqt0bx6yxr44ibfdyyj8lvelnmemrr 10 7 93 92 2018-06-14T17:07:52Z Kike GL 1 wikitext text/x-wiki <p style="color:green; background-color:#C0FFC0; border: 1px solid green; border-radius: 5px; margin-top: 20px; padding: 10px; position: relative;"> <b>Nota:</b> {{{1}}}</p> <noinclude> == Como usar nota == <p style="float:left;background:Peru;padding:10px;Border:1px solid brown;Border-Radius:5px;"><nowiki>{{nota|Pones tu comentario aqui}}</nowiki></p><p style="clear:both;">&nbsp;</p> == Lo que mostrara == {{nota|Pones tu comentario aqui}} <noinclude> 8vrr3u6smtjlgzocfh0lrtzxf9s8ixv 10 9 125 105 2018-06-15T00:03:39Z Kike GL 1 wikitext text/x-wiki <p style="color:purple;background-color: #FFCCFF;border: 1px solid purple;border-radius:5px;margin-top:20px;padding:10px;position:relative;"> Este articulo esta por revisar aun !</p> qk5ptrtdq58d4s9v2wg592jjbjjqqmo 10 460 4146 4145 2019-06-11T19:28:46Z Kike GL 2 wikitext text/x-wiki <p style="color:black; background-color:#ffffc0; border: 1px solid #ffb30f; border-radius: 5px; margin-top: 20px; padding: 10px; position: relative;"> <b>Tip:</b> {{{1}}}</p> <noinclude> == Como usar nota == <p style="float:left;background:Peru;padding:10px;Border:1px solid brown;Border-Radius:5px;"><nowiki>{{Tip|Pones tu comentario aqui}}</nowiki></p><p style="clear:both;">&nbsp;</p> == Lo que mostrara == {{Tip|Pones tu comentario aqui}} <noinclude> r383ouuwxi1js965enfms885bxgjdi7 14 230 997 2018-06-26T18:34:40Z Kike GL 2 Página creada con «[[Category:Ejemplos]]» wikitext text/x-wiki [[Category:Ejemplos]] hqrhzqyaiq1e4cirk21mby7ft6cm14l 14 438 5065 3779 2019-10-13T13:24:31Z Kike GL 2 wikitext text/x-wiki Categoría raiz de ArduWiki. Todas las categorías del proyecto son subcategorías directas o indirectas de ésta. cgry5t4wlknzc3kcuz3htctr49ecdy6 14 151 518 2018-06-20T21:57:04Z Kike GL 2 Página creada con «[[Category:Ejemplos]]» wikitext text/x-wiki [[Category:Ejemplos]] hqrhzqyaiq1e4cirk21mby7ft6cm14l 14 271 1049 2018-06-26T21:27:06Z Kike GL 2 Página creada con «[[Category:Ejemplos]]» wikitext text/x-wiki [[Category:Ejemplos]] hqrhzqyaiq1e4cirk21mby7ft6cm14l 14 243 1013 2018-06-26T21:01:35Z Kike GL 2 Página creada con «[[Category:Ejemplos]]» wikitext text/x-wiki [[Category:Ejemplos]] hqrhzqyaiq1e4cirk21mby7ft6cm14l 14 480 4664 2019-07-07T01:01:56Z Kike GL 2 Página creada con «Aqui van los ejemplos incluidos en el [[IDE]] [[Category:Ejemplos]]» wikitext text/x-wiki Aqui van los ejemplos incluidos en el [[IDE]] [[Category:Ejemplos]] qh1ws0oeuulo3gttbaikwbkkazexoz9 14 282 1063 2018-06-26T21:34:40Z Kike GL 2 Página creada con «[[Category:Arduino]]» wikitext text/x-wiki [[Category:Arduino]] 31em7o58rzde9t7lnwg6lvpa2if1zyr 14 116 560 311 2018-06-21T15:57:37Z Kike GL 2 wikitext text/x-wiki Los elementos del código Arduino (C ++). [[Category:Referencias]] jn5wgg1acb41fmz6x7zff9ur6f4obdx 14 440 3806 2019-05-06T23:09:31Z Kike GL 2 Página creada con «[[Category:Estructura]]» wikitext text/x-wiki [[Category:Estructura]] d7h5or4j84zq715jjb0zf86sq078qpl 14 283 1067 2018-06-26T21:41:54Z Kike GL 2 Página creada con «[[Category:Ejemplos]]» wikitext text/x-wiki [[Category:Ejemplos]] hqrhzqyaiq1e4cirk21mby7ft6cm14l 14 11 561 307 2018-06-21T15:58:44Z Kike GL 2 wikitext text/x-wiki Categoría que agrupa a todas la funciones internas en Arduino. [[Category:Referencias]] 3fk6b0au4h185lb64k3butnso00kggc 14 468 4970 4253 2019-09-26T16:18:55Z Kike GL 2 wikitext text/x-wiki A menudo, cuando se programa en el entorno Arduino, la capacidad de manipular bits individuales será útil o incluso necesaria. Aquí hay algunas situaciones en las que las matemáticas de bits pueden ser útiles: * Ahorro de memoria al empacar hasta 8 valores de datos verdaderos/falsos en un solo [[byte]]. * Activar/desactivar bits individuales en un registro de control o registro de puerto de hardware. * Realizar ciertas operaciones aritméticas que implican multiplicar o dividir por potencias de 2. En este tutorial, primero exploramos los operadores básicos bit a bit disponibles en el lenguaje C++. Luego aprendemos cómo combinarlos para realizar ciertas operaciones útiles comunes. == Sistema binario == Para entender las operaciones binarias es mucho mejor trabajar en numeros binarios. Arduino permite hacer esto: <pre> 0b11 //3 B11 //3 </pre> [[Category:Funciones]] abkl1gxc46cfdey1wm1isygf52n5wzb 14 464 4213 2019-06-11T21:26:02Z Kike GL 2 Página creada con «[[Category:Funciones]]» wikitext text/x-wiki [[Category:Funciones]] 5fwo2g0cy95qblmmzmd4n5lxfxei9mc 14 465 4227 2019-06-11T21:34:13Z Kike GL 2 Página creada con «[[Category:Funciones]]» wikitext text/x-wiki [[Category:Funciones]] 5fwo2g0cy95qblmmzmd4n5lxfxei9mc 14 469 4261 2019-06-11T23:09:53Z Kike GL 2 Página creada con «[[Category:Funciones]]» wikitext text/x-wiki [[Category:Funciones]] 5fwo2g0cy95qblmmzmd4n5lxfxei9mc 14 463 4201 2019-06-11T21:19:28Z Kike GL 2 Página creada con «[[Category:Funciones]]» wikitext text/x-wiki [[Category:Funciones]] 5fwo2g0cy95qblmmzmd4n5lxfxei9mc 14 467 4243 2019-06-11T22:43:38Z Kike GL 2 Página creada con «[[Category:Funciones]]» wikitext text/x-wiki [[Category:Funciones]] 5fwo2g0cy95qblmmzmd4n5lxfxei9mc 14 466 4235 2019-06-11T22:30:45Z Kike GL 2 Página creada con «[[Category:Funciones]]» wikitext text/x-wiki [[Category:Funciones]] 5fwo2g0cy95qblmmzmd4n5lxfxei9mc 14 462 4190 2019-06-11T21:13:15Z Kike GL 2 Página creada con «[[Category:Funciones]]» wikitext text/x-wiki [[Category:Funciones]] 5fwo2g0cy95qblmmzmd4n5lxfxei9mc 14 457 4068 2019-05-30T22:32:40Z Kike GL 2 Página creada con «[[Category:Librerias]]» wikitext text/x-wiki [[Category:Librerias]] k8o9klt777n6abmoqabigqm5jispqjo 14 430 3463 2019-05-06T00:00:00Z Kike GL 2 Página creada con « [[Category:Librerias]]» wikitext text/x-wiki [[Category:Librerias]] s5zzeiikczlxmc8oelhou34z3290hw5 14 429 3459 2019-05-05T23:56:42Z Kike GL 2 Página creada con « [[Category:Librerias]]» wikitext text/x-wiki [[Category:Librerias]] f76qlwtjp9t3vo9xkh0ydij7hcfis69 14 407 3454 3031 2019-05-05T23:54:43Z Kike GL 2 wikitext text/x-wiki Los temporizadores internos de Arduino son de corto plazo. Pero que hacer cuando requerimos por ejemplo poner fecha y hora en nuestro tabulado de datos de sensores (datalogger) para un análisis posterior ? Estas funciones están disponibles si añades la librería estándar de Arduino TimeLib.h. Lo primero que hace la librería TimeLib.h es definir un tipo especial de variable que llamamos time_t de 32 bits, que es la base de todo, porque almacena valores de tiempo en un formato especial calculado como el número de segundos transcurridos desde el 1-ENE-1970, llamada fecha Unix. [[Category:Librerias]] o39ruwns14rqti7qk0v40khuaca815v 14 285 5274 4682 2020-03-16T17:10:00Z Kike GL 2 wikitext text/x-wiki El software Arduino ([[IDE]]) se puede ampliar mediante el uso de librerías, al igual que la mayoría de las plataformas de programación, para proporcionar funcionalidad adicional a sus [[boceto]]s (sketches). A continuación listamos las librerías más importantes explicando su funcionamiento. Además le mostraremos ejemplos de varias librerías que vienen instaladas con el [[IDE]]. Para abrirlas haga clic en el menú de la barra de herramientas: Archivo>Ejemplos. {{Nota|Antes de usar una libreria, esta se debe instalar de preferencia mediante el Administrador de librerías que se encuentra en el IDE menu: Programa > Incluir Librerias > Administrar Bibliotecas.}} Existen varios tipos de libreria: * Partner (12) * Official (77) * Recommended (119) * Contributed (2508) * Retired (3) [[Category:Arduino]] o8rnymajdtlqisuxg5wlrtghktexxby 14 281 1062 2018-06-26T21:34:01Z Kike GL 2 Página creada con «[[Category:Ejemplos]]» wikitext text/x-wiki [[Category:Ejemplos]] hqrhzqyaiq1e4cirk21mby7ft6cm14l 14 470 4389 2019-06-14T23:11:22Z Kike GL 2 Página creada con «[[Category:Operador]]» wikitext text/x-wiki [[Category:Operador]] fcweoya3nfnf7o4umfxhha3twgckbew 14 439 3797 2019-05-06T23:05:14Z Kike GL 2 Página creada con «[[Category:Estructura]]» wikitext text/x-wiki [[Category:Estructura]] d7h5or4j84zq715jjb0zf86sq078qpl 14 495 5006 2019-09-26T23:55:48Z Kike GL 2 Página creada con «[[Category:Estructura]]» wikitext text/x-wiki [[Category:Estructura]] d7h5or4j84zq715jjb0zf86sq078qpl 14 441 3824 2019-05-06T23:17:57Z Kike GL 2 Página creada con «[[Category:Estructura]]» wikitext text/x-wiki [[Category:Estructura]] d7h5or4j84zq715jjb0zf86sq078qpl 14 496 5019 2019-09-27T00:02:32Z Kike GL 2 Página creada con «[[Category:Estructura]]» wikitext text/x-wiki [[Category:Estructura]] d7h5or4j84zq715jjb0zf86sq078qpl 14 494 5004 2019-09-26T23:54:16Z Kike GL 2 Página creada con «[[Category:Estructura]]» wikitext text/x-wiki [[Category:Estructura]] d7h5or4j84zq715jjb0zf86sq078qpl 14 442 3830 2019-05-06T23:21:34Z Kike GL 2 Página creada con «[[Category:Estructura]]» wikitext text/x-wiki [[Category:Estructura]] d7h5or4j84zq715jjb0zf86sq078qpl 14 436 3696 2019-05-06T19:02:09Z Kike GL 2 Página creada con «[[Category:Variables]]» wikitext text/x-wiki [[Category:Variables]] renp5md2l7iavfspf1fpp0th1jeaolx 14 252 1027 2018-06-26T21:16:08Z Kike GL 2 Página creada con «[[Category:Ejemplos]]» wikitext text/x-wiki [[Category:Ejemplos]] hqrhzqyaiq1e4cirk21mby7ft6cm14l 14 461 4662 4160 2019-07-07T00:55:02Z Kike GL 2 wikitext text/x-wiki Aqui las placas Arduino disponibles [[Category:Arduino]] ka8h0swtuggjwel5to7c8shs43u93sq 14 118 1064 303 2018-06-26T21:36:04Z Kike GL 2 wikitext text/x-wiki El lenguaje de programación de Arduino se puede dividir en tres grandes partes: estructura, valores (variables y constantes), y funciones. [[Category:Arduino]] ko0tts3ty8cnkbgskv05q1ahiml0zgb 14 257 1033 2018-06-26T21:19:55Z Kike GL 2 Página creada con «[[Category:Ejemplos]]» wikitext text/x-wiki [[Category:Ejemplos]] hqrhzqyaiq1e4cirk21mby7ft6cm14l 14 432 3500 2019-05-06T17:22:16Z Kike GL 2 Página creada con «[[Category:Funciones]]» wikitext text/x-wiki [[Category:Funciones]] 5fwo2g0cy95qblmmzmd4n5lxfxei9mc 14 433 3540 2019-05-06T17:43:15Z Kike GL 2 Página creada con «[[Category:Funciones]]» wikitext text/x-wiki [[Category:Funciones]] 5fwo2g0cy95qblmmzmd4n5lxfxei9mc 14 434 3589 2019-05-06T18:02:37Z Kike GL 2 Página creada con «[[Category:Funciones]]» wikitext text/x-wiki [[Category:Funciones]] 5fwo2g0cy95qblmmzmd4n5lxfxei9mc 14 278 1056 2018-06-26T21:30:36Z Kike GL 2 Página creada con «[[Category:Ejemplos]]» wikitext text/x-wiki [[Category:Ejemplos]] hqrhzqyaiq1e4cirk21mby7ft6cm14l 14 435 3670 2019-05-06T18:37:09Z Kike GL 2 Página creada con «[[Category:Variables]]» wikitext text/x-wiki [[Category:Variables]] renp5md2l7iavfspf1fpp0th1jeaolx 14 373 2039 2038 2018-07-15T16:49:06Z Kike GL 2 wikitext text/x-wiki [[Category:Estructura]] d7h5or4j84zq715jjb0zf86sq078qpl 14 117 562 308 2018-06-21T15:59:18Z Kike GL 2 wikitext text/x-wiki Tipos de datos en Arduino y constantes. [[Category:Referencias]] oixiky8qv32enb9ddjm09lqm8vrc4v4 14 437 4795 3766 2019-07-18T16:59:18Z Kike GL 2 wikitext text/x-wiki [[Category:Placas]] gwm16mzxht51o543b9zlbs6vsqfcxmo